chatroom-cli 1.138.2 → 1.139.0

package/dist/index.js

@@ -10016,6 +10016,33 @@ var init_rigging = __esm(() => {
   init_model_registry();
 });
 
+// src/commands/image-shared/writable-path.ts
+function dryRunOverwriteHint(dryRun) {
+  return dryRun ? DRY_RUN_OVERWRITE_HINT : undefined;
+}
+function directoryRefusal(target) {
+  return `${target.label} is a directory: ${target.path}. Pass a file path.`;
+}
+function fileRefusal(target) {
+  return `${target.label} already exists: ${target.path}. ${target.hint ?? OVERWRITE_HINT}`;
+}
+function blockedMessage(target, status, force) {
+  if (status === "directory")
+    return directoryRefusal(target);
+  if (status === "file" && !force)
+    return fileRefusal(target);
+  return null;
+}
+async function findUnwritablePathMessage(deps, targets, force) {
+  for (const target of targets) {
+    const message = blockedMessage(target, await deps.pathStatus(target.path), force);
+    if (message !== null)
+      return message;
+  }
+  return null;
+}
+var OVERWRITE_HINT = "Pass --force to overwrite.", DRY_RUN_OVERWRITE_HINT = "A real run would also refuse this. Add --force to print the plan; a dry run writes nothing; do not carry --force into the real run unless overwriting is intended.";
+
 // src/commands/generate-3d/generate-3d.ts
 var exports_generate_3d = {};
 __export(exports_generate_3d, {
@@ -10104,18 +10131,16 @@ async function validateInputImage(deps, inputImage) {
   }
   return { kind: "file", path: localPath, contentType };
 }
-async function requireWritablePath(deps, path, label, force, hint = "Pass --force to overwrite.") {
-  const status = await deps.pathStatus(path);
-  if (status === "directory") {
-    throw new Generate3dError(`${label} is a directory: ${path}. Pass a file path.`);
-  }
-  if (status === "file" && !force) {
-    throw new Generate3dError(`${label} already exists: ${path}. ${hint}`);
-  }
+async function requireWritablePaths(deps, targets, force) {
+  const message = await findUnwritablePathMessage(deps, targets, force);
+  if (message !== null)
+    throw new Generate3dError(message);
 }
-async function requireWritableOutput(deps, outPath, manifestPath, force) {
-  await requireWritablePath(deps, outPath, "--out", force);
-  await requireWritablePath(deps, manifestPath, "Manifest", force);
+async function requireWritableOutput(deps, outPath, manifestPath, force, dryRun) {
+  await requireWritablePaths(deps, [
+    { path: outPath, label: "--out", hint: dryRunOverwriteHint(dryRun) },
+    { path: manifestPath, label: "Manifest", hint: dryRunOverwriteHint(dryRun) }
+  ], force);
 }
 function planInputImageUrl(target) {
   if (target === undefined)
@@ -10186,13 +10211,17 @@ function buildRiggingPlan(outPath, rig, animationActionIds) {
     extraCostLines: riggingCostLines(animationActionIds.length)
   };
 }
-async function requireWritableRiggingPaths(deps, rigging, force) {
+async function requireWritableRiggingPaths(deps, rigging, force, dryRun) {
   if (rigging.riggedOutPath === null)
     return;
-  await requireWritablePath(deps, rigging.riggedOutPath, "Rigged GLB", force);
-  for (const animation of rigging.animationOutPaths) {
-    await requireWritablePath(deps, animation.path, `Animation clip ${animation.actionId} GLB`, force);
-  }
+  await requireWritablePaths(deps, [
+    { path: rigging.riggedOutPath, label: "Rigged GLB", hint: dryRunOverwriteHint(dryRun) },
+    ...rigging.animationOutPaths.map((animation) => ({
+      path: animation.path,
+      label: `Animation clip ${animation.actionId} GLB`,
+      hint: dryRunOverwriteHint(dryRun)
+    }))
+  ], force);
 }
 function packageFilePaths(packageDir, base) {
   return { zipPath: join2(packageDir, `${base}.zip`), htmlPath: join2(packageDir, `${base}.html`) };
@@ -10445,10 +10474,10 @@ function planReferenceStep(args) {
     costLines: [{ label: REFERENCE_IMAGE_COST_LABEL, usd: REFERENCE_IMAGE_COST_USD }]
   };
 }
-async function requireWritableReference(deps, reference, force) {
+async function requireWritableReference(deps, reference, force, dryRun) {
   if (reference?.source !== "generated" || reference.localPath === null)
     return;
-  await requireWritablePath(deps, reference.localPath, "Reference image", force);
+  await requireWritablePaths(deps, [{ path: reference.localPath, label: "Reference image", hint: dryRunOverwriteHint(dryRun) }], force);
 }
 function requireRigForClips(rig, animationActionIds) {
   if (animationActionIds.length > 0 && !rig) {
@@ -10456,13 +10485,16 @@ function requireRigForClips(rig, animationActionIds) {
   }
 }
 async function requireWritablePlanPaths(args) {
-  await requireWritableOutput(args.deps, args.outPath, args.manifestPath, args.force);
-  await requireWritableRiggingPaths(args.deps, args.rigging, args.force);
-  await requireWritablePackage(args.deps, args.naming, args.force);
+  await requireWritableOutput(args.deps, args.outPath, args.manifestPath, args.force, args.dryRun);
+  await requireWritableRiggingPaths(args.deps, args.rigging, args.force, args.dryRun);
+  await requireWritablePackage(args.deps, args.naming, args.force, args.dryRun);
 }
-async function requireWritablePackage(deps, paths, force) {
-  await requireWritablePath(deps, paths.zipPath, "Package", force, PACKAGE_COLLISION_HINT);
-  await requireWritablePath(deps, paths.htmlPath, "Preview", force, PACKAGE_COLLISION_HINT);
+async function requireWritablePackage(deps, paths, force, dryRun) {
+  const hint = dryRun ? DRY_RUN_PACKAGE_HINT : PACKAGE_COLLISION_HINT;
+  await requireWritablePaths(deps, [
+    { path: paths.zipPath, label: "Package", hint },
+    { path: paths.htmlPath, label: "Preview", hint }
+  ], force);
 }
 function resolvePlanTarget(opts) {
   const model = requireModel(opts.model);
@@ -10496,13 +10528,14 @@ async function planGenerate3d(opts, deps) {
   await requireWritablePlanPaths({
     deps,
     force: opts.force === true,
+    dryRun: opts.dryRun === true,
     outPath,
     manifestPath,
     rigging,
     naming
   });
   const referenceStep = planReferenceStep({ model, opts, outPath, inputTarget });
-  await requireWritableReference(deps, referenceStep.referenceImage, opts.force === true);
+  await requireWritableReference(deps, referenceStep.referenceImage, opts.force === true, opts.dryRun === true);
   const input = model.buildInput({
     prompt: opts.prompt,
     imageUrl: referenceStep.imageUrl,
@@ -11448,7 +11481,7 @@ async function generate3d(opts, deps) {
     costLines: formatGenerate3dCost(plan.costLines, plan.model.id, plan.generationCostKnown)
   };
 }
-var GLB_CONTENT_TYPE = "model/gltf-binary", GLB_EXTENSION = ".glb", PLANNED_MODEL_URL = "<generated mesh GLB URL>", RIGGING_HUMANOID_WARNING = "Rigging (Meshy) expects a humanoid mesh; non-humanoid meshes fail on fal.", WEB_VARIANT_TRIANGLE_TARGET = 30000, WEB_VARIANT_MAX_TEXTURE_PX = 1024, WEB_VARIANT_TEXTURE_QUALITY = 80, WEB_VARIANT_DATA_TEXTURE_QUALITY = 95, PACKAGE_MANIFEST_NAME = "manifest.json", PACKAGE_PRICING_NOTE = "list-price estimate, not a billed amount", HTTP_URL_PATTERN, INPUT_IMAGE_CONTENT_TYPES, INPUT_REQUIREMENTS, PACKAGE_COLLISION_HINT = "Another run used this name in the same second; wait a second, use a different --package-dir, or pass --force.", FLAG_CAPABILITY, INPUT_FLAG_NAMES, INPUT_PLACEHOLDERS, INPUT_CAPABILITY, RESERVED_INPUT_FLAGS, GENERATED_REFERENCE_URL = "<generated reference image URL>", WEB_VARIANT_OPTIONS, SILENT_LOGGER2;
+var GLB_CONTENT_TYPE = "model/gltf-binary", GLB_EXTENSION = ".glb", PLANNED_MODEL_URL = "<generated mesh GLB URL>", RIGGING_HUMANOID_WARNING = "Rigging (Meshy) expects a humanoid mesh; non-humanoid meshes fail on fal.", WEB_VARIANT_TRIANGLE_TARGET = 30000, WEB_VARIANT_MAX_TEXTURE_PX = 1024, WEB_VARIANT_TEXTURE_QUALITY = 80, WEB_VARIANT_DATA_TEXTURE_QUALITY = 95, PACKAGE_MANIFEST_NAME = "manifest.json", PACKAGE_PRICING_NOTE = "list-price estimate, not a billed amount", HTTP_URL_PATTERN, INPUT_IMAGE_CONTENT_TYPES, INPUT_REQUIREMENTS, PACKAGE_COLLISION_CAUSE = "Another run used this name in the same second; wait a second, use a different --package-dir", PACKAGE_COLLISION_HINT, DRY_RUN_PACKAGE_HINT, FLAG_CAPABILITY, INPUT_FLAG_NAMES, INPUT_PLACEHOLDERS, INPUT_CAPABILITY, RESERVED_INPUT_FLAGS, GENERATED_REFERENCE_URL = "<generated reference image URL>", WEB_VARIANT_OPTIONS, SILENT_LOGGER2;
 var init_generate_3d = __esm(() => {
   init_meshoptimizer();
   init_asset_analysis();
@@ -11469,6 +11502,8 @@ var init_generate_3d = __esm(() => {
     text: { flag: "--prompt", value: (opts) => opts.prompt },
     image: { flag: "--input-image", value: (opts) => opts.inputImage }
   };
+  PACKAGE_COLLISION_HINT = `${PACKAGE_COLLISION_CAUSE}, or pass --force.`;
+  DRY_RUN_PACKAGE_HINT = `${PACKAGE_COLLISION_CAUSE}. ${DRY_RUN_OVERWRITE_HINT}`;
   FLAG_CAPABILITY = {
     "--prompt": "prompt",
     "--input-image": "image",
@@ -11618,16 +11653,16 @@ function packageBase(zipName, zipPath) {
   }
   return zipName.slice(0, -".zip".length);
 }
-async function requireWritablePreview(htmlPath, force) {
-  const stats = await stat2(htmlPath).catch(() => null);
+async function previewPathStatus(path) {
+  const stats = await stat2(path).catch(() => null);
   if (stats === null)
-    return;
-  if (stats.isDirectory()) {
-    throw new Error(`Preview is a directory: ${htmlPath}. Pass a file path.`);
-  }
-  if (!force) {
-    throw new Error(`Preview already exists: ${htmlPath}. Pass --force to overwrite.`);
-  }
+    return "missing";
+  return stats.isDirectory() ? "directory" : "file";
+}
+async function requireWritablePreview(htmlPath, force) {
+  const message = await findUnwritablePathMessage({ pathStatus: previewPathStatus }, [{ path: htmlPath, label: "Preview" }], force);
+  if (message !== null)
+    throw new Error(message);
 }
 async function writePreview(htmlPath, html, force) {
   await requireWritablePreview(htmlPath, force);
@@ -11852,16 +11887,17 @@ function readPngDimensions(bytes) {
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   return { width: view.getUint32(16), height: view.getUint32(20) };
 }
-function formatConflicts(conflicts) {
+function formatConflicts(conflicts, dryRun) {
   const shown = conflicts.slice(0, 10);
   const lines = shown.map((conflict) => `- ${conflict.path}: ${conflict.reason}`);
   if (conflicts.length > shown.length) {
     lines.push(`- and ${conflicts.length - shown.length} more`);
   }
+  const hint = dryRunOverwriteHint(dryRun) ?? "Pass --force to overwrite.";
   return `Refusing to write ${conflicts.length} output file(s):
 ${lines.join(`
 `)}
-Pass --force to overwrite.`;
+${hint}`;
 }
 async function findOutputConflicts(deps, paths, sourcePaths, sourceIdentities, force) {
   const matchesSourceIdentity = (identity) => sourceIdentities.some((source) => source !== null && source.dev === identity.dev && source.ino === identity.ino);
@@ -12149,18 +12185,16 @@ function requireImage2(images, model) {
   }
   return image;
 }
-async function requireWritablePath2(deps, path, label, force) {
-  const status = await deps.pathStatus(path);
-  if (status === "directory") {
-    throw new GenerateImageError(`${label} is a directory: ${path}. Pass a file path.`);
-  }
-  if (status === "file" && !force) {
-    throw new GenerateImageError(`${label} already exists: ${path}. Pass --force to overwrite.`);
-  }
+async function requireWritablePaths2(deps, targets, force) {
+  const message = await findUnwritablePathMessage(deps, targets, force);
+  if (message !== null)
+    throw new GenerateImageError(message);
 }
-async function requireWritableOutput2(deps, outPath, manifestPath, force) {
-  await requireWritablePath2(deps, outPath, "--out", force);
-  await requireWritablePath2(deps, manifestPath, "Manifest", force);
+async function requireWritableOutput2(deps, outPath, manifestPath, force, dryRun) {
+  await requireWritablePaths2(deps, [
+    { path: outPath, label: "--out", hint: dryRunOverwriteHint(dryRun) },
+    { path: manifestPath, label: "Manifest", hint: dryRunOverwriteHint(dryRun) }
+  ], force);
 }
 function recoveryMessage(action, err2, requestId, url) {
   const detail = err2 instanceof Error ? err2.message : String(err2);
@@ -12433,7 +12467,7 @@ async function planGenerateImage(opts, deps) {
   validateInputOption(opts);
   const inputTarget = await validateInputImage2(deps, inputImage);
   const manifestPath = `${outPath}.json`;
-  await requireWritableOutput2(deps, outPath, manifestPath, opts.force === true);
+  await requireWritableOutput2(deps, outPath, manifestPath, opts.force === true, opts.dryRun === true);
   const input = buildInput(prompt, opts, planInputImageUrl2(inputTarget));
   const cost = await buildGenerateImageCost({ model, input, inputTarget, deps });
   return {
@@ -14763,18 +14797,16 @@ function requireMatchingDimensions(args) {
   }
   return result;
 }
-async function requireWritablePath3(path, label, force, deps) {
-  const status = await deps.pathStatus(path);
-  if (status === "directory") {
-    throw new RemoveBackgroundFalError(`${label} is a directory: ${path}. Pass a file path.`);
-  }
-  if (status === "file" && !force) {
-    throw new RemoveBackgroundFalError(`${label} already exists: ${path}. Pass --force to overwrite.`);
-  }
+async function requireWritablePaths3(deps, targets, force) {
+  const message = await findUnwritablePathMessage(deps, targets, force);
+  if (message !== null)
+    throw new RemoveBackgroundFalError(message);
 }
 async function requireWritableOutputs(outPath, manifestPath, force, deps) {
-  await requireWritablePath3(outPath, "--out", force, deps);
-  await requireWritablePath3(manifestPath, "Manifest", force, deps);
+  await requireWritablePaths3(deps, [
+    { path: outPath, label: "--out" },
+    { path: manifestPath, label: "Manifest" }
+  ], force);
 }
 function manifestSaveMessage(err2, requestId, outPath, manifestPath) {
   const detail = err2 instanceof Error ? err2.message : String(err2);
@@ -48679,6 +48711,8 @@ var init_errorCodes = __esm(() => {
     EMPTY_PROMPT: "EMPTY_PROMPT",
     INVALID_SCHEDULE: "INVALID_SCHEDULE",
     LIFECYCLE_DISABLED: "LIFECYCLE_DISABLED",
+    NOTHING_TO_UPDATE: "NOTHING_TO_UPDATE",
+    SCHEDULE_FINISHED: "SCHEDULE_FINISHED",
     TITLE_REQUIRED: "TITLE_REQUIRED",
     TITLE_TOO_LONG: "TITLE_TOO_LONG",
     HARNESS_SESSION_ALREADY_ASSOCIATED: "HARNESS_SESSION_ALREADY_ASSOCIATED",
@@ -48694,6 +48728,18 @@ var init_errorCodes = __esm(() => {
     INVITE_INVALID: "INVITE_INVALID",
     INVITE_EMAIL_MISMATCH: "INVITE_EMAIL_MISMATCH",
     SIGNUP_DISABLED: "SIGNUP_DISABLED",
+    FILE_ATTACHMENT_NOT_FOUND: "FILE_ATTACHMENT_NOT_FOUND",
+    FILE_ATTACHMENT_INVALID_STATE: "FILE_ATTACHMENT_INVALID_STATE",
+    FILE_ATTACHMENT_INVALID: "FILE_ATTACHMENT_INVALID",
+    FILE_ATTACHMENT_TOO_LARGE: "FILE_ATTACHMENT_TOO_LARGE",
+    FILE_ATTACHMENT_TYPE_NOT_ALLOWED: "FILE_ATTACHMENT_TYPE_NOT_ALLOWED",
+    FILE_ATTACHMENT_INVALID_FILENAME: "FILE_ATTACHMENT_INVALID_FILENAME",
+    FILE_ATTACHMENT_EXCEEDS_QUOTA: "FILE_ATTACHMENT_EXCEEDS_QUOTA",
+    FILE_ATTACHMENT_LIMIT_EXCEEDED: "FILE_ATTACHMENT_LIMIT_EXCEEDED",
+    FILE_ATTACHMENT_TOO_MANY_PENDING: "FILE_ATTACHMENT_TOO_MANY_PENDING",
+    FILE_ATTACHMENTS_REQUIRE_USER_TARGET: "FILE_ATTACHMENTS_REQUIRE_USER_TARGET",
+    FILE_UPLOADS_UNAVAILABLE: "FILE_UPLOADS_UNAVAILABLE",
+    WEB_SESSION_REQUIRED: "WEB_SESSION_REQUIRED",
     CONFLICT: "CONFLICT"
   };
   FATAL_ERROR_CODES = [
@@ -48788,6 +48834,8 @@ var init_errorCodes = __esm(() => {
     BACKEND_ERROR_CODES.EMPTY_PROMPT,
     BACKEND_ERROR_CODES.INVALID_SCHEDULE,
     BACKEND_ERROR_CODES.LIFECYCLE_DISABLED,
+    BACKEND_ERROR_CODES.NOTHING_TO_UPDATE,
+    BACKEND_ERROR_CODES.SCHEDULE_FINISHED,
     BACKEND_ERROR_CODES.TITLE_REQUIRED,
     BACKEND_ERROR_CODES.TITLE_TOO_LONG,
     BACKEND_ERROR_CODES.HARNESS_SESSION_ALREADY_ASSOCIATED,
@@ -48818,7 +48866,19 @@ var init_errorCodes = __esm(() => {
     BACKEND_ERROR_CODES.HARNESS_SESSION_INVALID_AGENT,
     BACKEND_ERROR_CODES.HARNESS_SESSION_INVALID_PROMPT,
     BACKEND_ERROR_CODES.HARNESS_SESSION_CLOSED,
-    BACKEND_ERROR_CODES.HARNESS_SESSION_UNKNOWN_AGENT
+    BACKEND_ERROR_CODES.HARNESS_SESSION_UNKNOWN_AGENT,
+    BACKEND_ERROR_CODES.FILE_ATTACHMENT_NOT_FOUND,
+    BACKEND_ERROR_CODES.FILE_ATTACHMENT_INVALID_STATE,
+    BACKEND_ERROR_CODES.FILE_ATTACHMENT_INVALID,
+    BACKEND_ERROR_CODES.FILE_ATTACHMENT_TOO_LARGE,
+    BACKEND_ERROR_CODES.FILE_ATTACHMENT_TYPE_NOT_ALLOWED,
+    BACKEND_ERROR_CODES.FILE_ATTACHMENT_INVALID_FILENAME,
+    BACKEND_ERROR_CODES.FILE_ATTACHMENT_EXCEEDS_QUOTA,
+    BACKEND_ERROR_CODES.FILE_ATTACHMENT_LIMIT_EXCEEDED,
+    BACKEND_ERROR_CODES.FILE_ATTACHMENT_TOO_MANY_PENDING,
+    BACKEND_ERROR_CODES.FILE_ATTACHMENTS_REQUIRE_USER_TARGET,
+    BACKEND_ERROR_CODES.FILE_UPLOADS_UNAVAILABLE,
+    BACKEND_ERROR_CODES.WEB_SESSION_REQUIRED
   ];
 });
 
@@ -72693,7 +72753,9 @@ function getArchitectRequirements() {
 - Analyze concurrency and races: concurrent writers, idempotency, ordering and monotonicity, retries, transactions, and failure/recovery behavior.
 - Design read patterns first: primary read paths, indexes, projections/read models, query shapes, scan and transaction limits, and invalidation/subscription scope.
 - Account for Convex reactivity and bandwidth: query invalidation patterns, avoiding unnecessary reactive fanout, and separating high-frequency heartbeat/liveness/status fields from low-frequency identity/configuration fields.
-- Specify concrete schema, query, and mutation changes; migration/backfill sequence; tests; and verification order.`;
+- Specify concrete schema, query, and mutation changes; migration/backfill sequence; tests; and verification order.
+- Make every new or changed interface complete: list each method or field with its callers, its inputs and outputs, and the failure modes it must signal to those callers. An interface with an unnamed caller or an unspecified failure mode is incomplete.
+- Apply the deletion test to every new module, class, or abstraction: name what complexity would reappear across its callers if it were deleted. A module that fails the test (its callers would be no more complex without it) must be removed from the design.`;
 }
 function getEntryPointToArchitectHandoffTemplate(query) {
   const entryPoint = query.fromRole;
@@ -72701,7 +72763,7 @@ function getEntryPointToArchitectHandoffTemplate(query) {
 
 Use this before any backend contract, API, or schema/persistence change.
 
-Provide the request, relevant constraints, and the files or product surfaces that need inspection. Ask for one evidence-backed design focused on ${getArchitectFocus()}.
+Provide the request, relevant constraints, and the files or product surfaces that need inspection. Name any prior decision in \`memory/\` or \`docs/\` the design must respect, and name the known test constraints (for example, an existing fake, or a rule that tests run against a real database). Ask for one evidence-backed design focused on ${getArchitectFocus()}.
 
 After completing the design, the \`architect\` must hand it back to \`${entryPoint}\` with the normal handoff command, then stop; it must not implement the design or delegate further work.
 
@@ -72729,6 +72791,8 @@ function getArchitectToEntryPointHandoffTemplate(query) {
 <cite the inspected repository patterns and complete the architect checklist below; do not provide a high-level essay>
 - Produce exactly one recommended design for ${getArchitectFocus()}.
 - Name concrete repository paths, existing abstractions, APIs/types, state/data flow, acceptance criteria, risks, and verification steps.
+- Name every seam the design introduces. A test seam is the public interface where a test observes behavior. Substitution in a test is allowed only at a port or adapter boundary (an external dependency injected through a port). Do not mock internal collaborators. Each seam must have a named consumer: a test that substitutes it, or a second real adapter. Do not introduce a seam with neither.
+- Check \`memory/\` and \`docs/\` for prior decisions about the area being designed. Cite each relevant decision by path and state whether the design preserves it or overturns it, with the reason. Verify each path exists with \`ls\` before citing it.
 ${getArchitectRequirements()}
 
 ## Force Multipliers
@@ -73071,7 +73135,7 @@ ${getHandoffQualityPrinciplesSectionBlock()}
 ## Proof of Completion
 ${getDelegationBriefDisclosureBlock()}
 ${getFileReferenceProofOfCompletionExample()}
-<evidence the goal was met — list every file you modified>
+<evidence the goal was met — list every file you modified; for each behavior the brief's \`## Test seams\` section names a seam for: the test name, the seam it calls, the failure output observed before the implementation, and the passing output after>
 
 ## Code Change Verification
 ${CODE_CHANGE_VERIFICATION_CONFIRMATION}
@@ -73082,7 +73146,7 @@ ${getHandoffNotApplicableSectionComment("List blockers")}
 
 ## Notes for review
 ${getHandoffNotApplicableSectionComment("List review notes")}
-<specific areas for planner to check>
+<specific areas for planner to check; any test written at a seam other than the one the brief's \`## Test seams\` section named, and why>
 \`\`\``;
 }
 function getBuilderPlannerCodeTemplate(query) {
@@ -73143,35 +73207,30 @@ function formatProofOfPrinciples() {
 var GAME_ASSET_RULES;
 var init_game_asset_designer_workflow = __esm(() => {
   GAME_ASSET_RULES = [
-    "Generate 2D assets only with `chatroom generate-image --platform=fal --model <Model>`, where <Model> is the brief's Model: `fal-ai/flux-2/flash` (FLUX 2 Flash), or `fal-ai/flux-2/flash/edit` with --input-image for reference edits. Generate a 3D model only with `chatroom generate-3d --platform=fal --model <Model>`, where <Model> is the brief's Model and is a fal 3D model id (`chatroom generate-3d --help` lists the known ids and their flags); the default is `fal-ai/trellis-2`, where a prompt generates a reference image first and that image ships in the zip. Pass --rig and --animation-action-id only for `meshy/v7.1` models, only when the brief asks for them, and only after the user confirms the priced dry run (a real run needs --confirm-cost). Pass --confirm-cost only when ## Cost confirmation quotes the user's approval; otherwise run --dry-run, return the priced plan, and do not pass --confirm-cost. A 3D run writes `<base>.zip` (`<stem>.glb`, `web/<stem>.web.glb`, `manifest.json`, the reference image when one was generated or supplied, and the rigged and animation GLBs with their web versions when rigging ran) and `<base>.html`, a separate preview of the web variant; `<base>` is the `--out` stem plus the run's UTC timestamp, and `--package-dir <dir>` (default: the master's directory) moves both.",
-    "Process images only with `chatroom slice-image` and `chatroom remove-image-background`; no other tool, script, or remote service.",
-    "A sheet is at most the brief's `Sheet grid` (default 2x2); a larger grid needs a user request quoted in the brief.",
-    "Names come from looking at each tile, never from cell order or prompt order.",
-    "Never pass `--names` to `slice-image` except P8's fallback when `remove-image-background --help` fails; assign names only with `remove-image-background --map` or `--out`.",
     "Write only under `Output location` and `Allowed edit paths`; never overwrite or delete unless the brief names the path.",
     "Mark `pass` or `fail` only with `measured` or `inspected` evidence (labels below).",
-    "Run `<command> --help` before first use of `slice-image`, `remove-image-background`, or `generate-3d`.",
-    "Always pass `--trim` to `chatroom remove-image-background`; use `--trim-padding` only when the brief names a padding.",
-    "If `generate-image` or `generate-3d` is missing, `FAL_API_KEY` is not set, or the generator fails, stop generation, deliver `spec only`, quote the exact error in Summary, and list it under Open questions. Do not retry in a loop.",
+    "If the generator is missing, `FAL_API_KEY` is not set, or generation fails, stop generation, deliver `spec only`, quote the exact error in Summary, and list it under Open questions. Do not retry in a loop.",
     "Do not install or run any remote tool, script, or skill, and do not fetch generator code.",
     "Never switch generators.",
     "Describe generated output as production-ready only when every checklist item for it passes with `measured` or `inspected` evidence.",
     "Commit only when the brief names the paths and the commit message.",
     "Generate only when the brief names an output location and allowed tools.",
-    "Before the first real call of each command shape (sheet, per-asset, reference edit, or 3D model), run the same command with --dry-run and apply every constraint it prints; take model-specific constraints only from the dry run, never from memory."
+    "You own the lighting and palette anchor for the asset set: from the brief's `## Lighting contract` and `## Style reference`, define one shared anchor (palette, light direction, colour temperature, background, material treatment) and repeat it word for word in every prompt of the set. Write every prompt yourself; the brief states goals and constraints, not prompts.",
+    'Honour the `## Lighting contract`: no lighting may be baked into the base colour. If the generator\'s whole-surface metal warning (named in `game-asset-3d-ai`) remains after one regeneration, or any other material warning remains, report it under Open questions. The **rig reference render** is "the existing render of the target rig, attached by path under `## Lighting contract`, used as a style target before generation. It is input only and cannot support `pass`."',
+    "Verify lighting under the target conditions, not the generator's. A `pass` also needs an **asset-in-rig render**: \"a render of the generated asset loaded in the project's real scene after generation, attached by path under `## Lighting verification`. Only this render supports `pass`.\" Producing it is never your job. Without it the lighting checklist item is `not checked`, which blocks delivery (the Summary starts `Delivered, lighting not verified:`). The lighting item is `n/a` when the brief's `## Lighting contract` is `Not applicable.`"
   ];
 });
 
 // ../../services/backend/prompts/teams/game-asset-designer-handoff-templates.ts
 function getEntryPointToGameAssetDesignerHandoffTemplate(query) {
   const entryPoint = query.fromRole;
-  return `Instructions (not part of the message): Pass the asset request as a brief the designer can act on without guessing. Provide every field below; write \`Not specified.\` for a field you cannot fill and the designer will ask or apply a stated default. Give each asset a stable ID (\`A01\`, \`A02\`…). Use \`spec only\` only when you want a specification with no files; the default is \`spec and generate\`. The \`## Allowed tools\` value is fixed: \`chatroom generate-image --platform=fal --model <Model> (dry run first), chatroom generate-3d --platform=fal --model <Model> (dry run first), chatroom slice-image, chatroom remove-image-background\`. Do not name any other generator; for a 3D model also fill \`## Output paths\`, whose \`--package-dir\` stays on the \`generate-3d\` entry. Before generating anything, the designer evaluates each \`## Free asset candidates\` entry and records a \`use\`, \`adapt\`, or \`reject\` decision; it generates only the assets that no candidate covers.
+  return `Instructions (not part of the message): Pass the asset request as a brief the designer can act on without guessing. Provide every field below; write \`Not specified.\` for a field you cannot fill and the designer will ask or apply a stated default, except \`## Lighting contract\`, which is required for a brief with any 3D asset and may be \`Not applicable.\` only when the brief has only 2D or audio assets. Pass goals and constraints as an open problem: do not author prompts, material treatment, style, or lighting art direction; the designer proposes the palette, lighting anchor, and prompts. Give each asset a stable ID (\`A01\`, \`A02\`…). Use \`spec only\` only when you want a specification with no files; the default is \`spec and generate\`. In \`## Allowed tools\`, keep the fixed line for each domain the brief contains and delete the others; name no other tool or generator. See the matching skill for how each tool is used. For a 3D model generated with AI also fill \`## Output paths\`; a procedural asset uses \`## Output location\` and the brief's allowed edit paths instead. Before generating anything, the designer evaluates each \`## Free asset candidates\` entry and records a \`use\`, \`adapt\`, or \`reject\` decision; it generates only the assets that no candidate covers. For a verification-only lighting brief, name the existing generated asset paths and the asset-in-rig render under \`## Existing assets\`; the designer applies only the lighting checklist item and does not generate, slice, or package.
 
 ## Asset request
 <one to three sentences: what the assets are for and the user-visible goal>
 
 ## Target
-<engine and version; genre and camera; platform tier (mobile, PC, console, VR); render pipeline if known>
+<engine and version; genre and camera; platform tier (mobile, PC, console, VR); render pipeline (renderer, tone mapping) if known; lighting goes in the Lighting contract>
 
 ## Assets requested
 <numbered list with stable IDs \`A01\`, \`A02\`…; each item: asset name, category (3D model, PBR textures, 2D sprite/UI, audio, other), purpose, quantity or variants>
@@ -73182,26 +73241,29 @@ function getEntryPointToGameAssetDesignerHandoffTemplate(query) {
 ## Style reference
 <repository paths, URLs, or a written style sheet; or \`Not specified.\`>
 
+## Lighting contract
+<required for a brief with any 3D asset; \`Not specified.\` is not allowed, and \`Not applicable.\` is only for a brief with only 2D or audio assets. State the goal ("consistent with the game's rig and palette") plus the rig facts the repo defines: lighting model (image-based / directional / unlit / toon); environment map present or absent; metalness policy; exposure and tone mapping; colour space; shadow setup; the repository paths that define the rig; and a **rig reference render** path (required for a 3D asset; the designer cannot produce it): "the existing render of the target rig, attached by path under \`## Lighting contract\`, used as a style target before generation. It is input only and cannot support \`pass\`." The **asset-in-rig render** is "a render of the generated asset loaded in the project's real scene after generation, attached by path under \`## Lighting verification\`. Only this render supports \`pass\`." If you do not know a fact write \`Unknown: designer to read <path>\`. Do not write prompts, material treatment, or art direction; the designer owns those.>
+
 ## Perspective
-<one camera perspective shared by every asset in the set, for example \`orthographic front view\`, \`orthographic isometric\`, \`dimetric 2:1\`, or \`side view\`; optionally \`reference: <repository path>\` of an existing asset to match (requires \`## Model\` = \`fal-ai/flux-2/flash/edit\`); a reference makes every asset an individual edit, with no sheets; \`Not Applicable.\` for 3D models and audio; or \`Not specified.\`>
+<one camera perspective shared by every asset in the set, for example \`orthographic front view\`, \`orthographic isometric\`, \`dimetric 2:1\`, or \`side view\`; optionally \`reference: <repository path>\` of an existing asset to match. A reference constrains \`## Model\` to a reference-edit model, and every asset is then generated individually; the matching skill states which. \`Not Applicable.\` for 3D models and audio; or \`Not specified.\`>
 
 ## Model
-<for a 2D asset: \`fal-ai/flux-2/flash\` (FLUX 2 Flash), passed as --model; \`fal-ai/flux-2/flash/edit\` only when \`## Perspective\` names a reference asset. For a 3D model: one fal 3D model id; \`chatroom generate-3d --help\` lists the known ids and the flags each takes>
+<for a 2D asset: \`fal-ai/flux-2/flash\` (FLUX 2 Flash), passed as --model; \`fal-ai/flux-2/flash/edit\` only when \`## Perspective\` names a reference asset. For a 3D asset generated with AI: one fal 3D model id; \`chatroom generate-3d --help\` lists the known ids and the flags each takes. For a procedural 3D asset: \`procedural: <generator script path>\`. For a mixed brief, give one line per domain prefixed \`AI 2D:\` / \`AI 3D:\` / \`Procedural 3D:\`, matching the Allowed tools prefixes.>
 
 ## Model parameters
-<a JSON object as text passed to \`generate-image --input\`, or to \`generate-3d --input\` for a 3D model; one object for every call of a set; its keys must pass the model's --dry-run check; \`Not specified.\` if none>
+<a JSON object of model parameters, one object for every call of a set; its keys must pass the model's parameter check. For a mixed brief, give one line per domain prefixed \`AI 2D:\` / \`AI 3D:\` / \`Procedural 3D:\`, matching the Allowed tools prefixes. \`Not specified.\` if none. \`Not applicable.\` for a procedural asset (its parameters live in the config file named in \`## Allowed edit paths\`).>
 
 ## Cost confirmation
-<the user's quoted approval of the priced dry run, with the estimate it approved; or Not confirmed.>
+<the user's quoted approval of the priced generation plan, with the estimate it approved; or Not confirmed. \`Not applicable.\` for a procedural asset (no fal cost).>
 
 ## Output paths
-<for a 3D model: the \`--out\` path, whose file name becomes the package base \`<out-stem>-<timestamp>\`, and the optional \`--package-dir\` directory (default: the master's directory). The run writes \`<base>.zip\` (\`<stem>.glb\`, \`web/<stem>.web.glb\`, \`manifest.json\`) and \`<base>.html\`, a separate preview of the web variant, beside the master or in that directory. \`Not Applicable.\` for a 2D-only request>
+<for a 3D model generated with AI: the \`--out\` path and the optional \`--package-dir\`; the run writes the package beside the master, and the matching skill names the files. \`Not Applicable.\` for a 2D-only request and for a procedural asset: its export path comes from \`## Output location\`, and its script, config, and output are named in \`## Allowed edit paths\`.>
 
 ## Spec consumer
 <who integrates these assets from the spec: \`builder\` (application logic outside the allowed edit paths) or \`user\`; asset files themselves are generated only by \`game-asset-designer\`>
 
 ## Existing assets
-<repository paths the designer must reuse or must not overwrite; or \`Not specified.\`>
+<repository paths the designer must reuse or must not overwrite; for a verification-only lighting brief, the existing generated asset paths and the asset-in-rig render path; or \`Not specified.\`>
 
 ## Free asset candidates
 <one entry per third-party pack to evaluate before generating: pack name, source URL, expected licence (for example CC0), formats, and the asset IDs it could cover; or \`None.\`. The designer checks each pack's own licence file and file sizes and gives each candidate a \`use\`, \`adapt\`, or \`reject\` decision. It fetches only the URLs named here, inspects the pack as static files, and never runs its code.>
@@ -73210,7 +73272,10 @@ function getEntryPointToGameAssetDesignerHandoffTemplate(query) {
 <\`spec and generate\` (default when you name an output location and allowed tools) or \`spec only\`>
 
 ## Allowed tools
-\`chatroom generate-image --platform=fal --model <Model> (dry run first), chatroom generate-3d --platform=fal --model <Model> (dry run first), chatroom slice-image, chatroom remove-image-background\`
+<keep the line for each domain the brief contains and delete the others; \`None.\` for \`spec only\`.
+AI 2D: \`chatroom generate-image --platform=fal --model <Model> (dry run first), chatroom slice-image, chatroom remove-image-background\`
+AI 3D: \`chatroom generate-3d --platform=fal --model <Model> (dry run first), gltf-transform inspect\`
+Procedural 3D: \`<generator script path> <run command>, git rev-parse HEAD, gltf-transform inspect\`>
 
 ## Allowed edit paths
 <repository-relative paths the designer may edit; \`None.\` for none>
@@ -73259,12 +73324,14 @@ function getGameAssetDesignerToEntryPointHandoffTemplate(query) {
 
 ## Proof of Principles
 ${PROOF_OF_PRINCIPLES_REPORT}
+- [ ] <append the domain Proof of Principles lines the matching skill lists, one per line>
 
 ## Proof of Completion
 - [ ] <one checkbox per brief acceptance criterion; state the evidence label required (measured or inspected)>
 - [ ] Every asset ID has a file or \`Specified only.\`
-- [ ] Every sliced asset was isolated with \`remove-image-background\` and \`inspected\`.
+- [ ] Every sheet-derived asset was isolated and \`inspected\`.
 - [ ] Manifests are listed in the asset manifest.
+- [ ] Lighting verified under the brief's Lighting contract with an **asset-in-rig render**: "a render of the generated asset loaded in the project's real scene after generation, attached by path under \`## Lighting verification\`. Only this render supports \`pass\`." The **rig reference render** is "the existing render of the target rig, attached by path under \`## Lighting contract\`, used as a style target before generation. It is input only and cannot support \`pass\`."; otherwise the Summary starts \`Delivered, lighting not verified:\`.
 - [ ] Every candidate in the brief has a decision with its licence and file sizes labelled \`inspected\`.
 
 ## Target and assumptions
@@ -73274,7 +73341,7 @@ ${PROOF_OF_PRINCIPLES_REPORT}
 <one entry per candidate in the brief: pack name, licence quoted from the pack's own licence file, file sizes checked, decision (\`use\`, \`adapt\`, or \`reject\`), asset IDs covered, and the reason; for \`adapt\`, the edits made; write exactly \`None.\` if the brief named no candidates>
 
 ## Asset manifest
-<one entry per asset, keyed by the planner's stable ID (\`A01\`…): name, category, file format, path (or \`Specified only.\`), dimensions/units/scale, pivot, naming, LOD list with triangle budgets, texture set with resolution, color space and channel packing, atlas/pixel grid/frame data, audio format and loudness target, import settings, dependencies and variants; for each budget, the acceptance check (exact command and expected value); for each generated file, the generator command line (\`chatroom generate-image\` with its \`--platform\`, \`--model\`, \`--seed\`, \`--input\`, and \`--input-image\` values, or \`chatroom generate-3d\` with its \`--platform\`, \`--model\`, \`--prompt\`/\`--input-image\`, \`--input\`, \`--rig\`, and \`--animation-action-id\` values), the sheet and tile manifests, and the isolated asset manifest path>
+<one entry per asset, keyed by the planner's stable ID (\`A01\`…): name, category, file format, path (or \`Specified only.\`), dimensions/units/scale, pivot, naming, LOD list with triangle budgets, texture set with resolution, color space and channel packing, atlas/pixel grid/frame data, audio format and loudness target, import settings, dependencies and variants; for each budget, the acceptance check (exact command and expected value); for each generated file, the command line the matching skill requires (model, seed, parameters, and any generator-specific flags), the sheet and tile manifests, and the isolated asset manifest path>
 
 ## Quality checklist results
 <per asset: each applicable checklist item as \`pass\`, \`fail\`, \`n/a\`, or \`not checked\`, with its evidence label and, for \`measured\`, the command and value; write exactly \`None failed.\` after the list if no item failed>
@@ -73282,6 +73349,9 @@ ${PROOF_OF_PRINCIPLES_REPORT}
 ## Style consistency
 <how the set matches the style reference; deviations; what was compared and how>
 
+## Lighting verification
+<per 3D asset: the lighting contract you applied; the shared palette/lighting anchor you used; an **asset-in-rig render**: "a render of the generated asset loaded in the project's real scene after generation, attached by path under \`## Lighting verification\`. Only this render supports \`pass\`."; the **rig reference render** path: "the existing render of the target rig, attached by path under \`## Lighting contract\`, used as a style target before generation. It is input only and cannot support \`pass\`."; result \`pass\`, \`fail\`, or \`not checked\` with its evidence label. For an AI-generated 3D asset also record the preview inspection marked \`not checked\` with the reason "no allowed capture tool" (no allowed tool captures Directional or Unlit views; Studio is image-based lighting and is never evidence); a procedural asset has no preview. In a verification-only brief (existing asset paths and an asset-in-rig render named), apply only this lighting item to those files; do not regenerate, slice, or package. If any asset is \`not checked\`, the Summary must start \`Delivered, lighting not verified:\`. Write \`n/a\` for 2D-only or audio-only requests and for \`spec only\` deliverables (no asset is rendered).>
+
 ## Naming map
 | cell stem | seen | assigned name | path | inspection note |
 | --- | --- | --- | --- | --- |
@@ -73322,7 +73392,7 @@ var init_game_asset_designer_handoff_templates = __esm(() => {
   init_game_asset_designer_evidence();
   init_game_asset_designer_workflow();
   init_command2();
-  PROOF_OF_PRINCIPLES_REPORT = GAME_ASSET_RULES.map((rule) => `- [ ] ${rule} — <evidence: command lines, grid values, or naming map reference>`).join(`
+  PROOF_OF_PRINCIPLES_REPORT = GAME_ASSET_RULES.map((rule) => `- [ ] ${rule} — <evidence: command lines and output values; grid values when a sheet was generated; naming map reference when names came from a mapping>`).join(`
 `);
 });
 
@@ -73383,6 +73453,8 @@ function getPlannerBuilderCodeBody() {
 
 **Detail bar:** Specify down to **every file** the builder will create or modify (full repo paths). Include code snippets — types, signatures, stubs, or target implementations — until a competent builder **cannot misinterpret** what to write. Vague layers ("update the backend", "fix the component") are not acceptable.
 
+**Test seams:** Fill \`## Test seams\` in the brief body for each behavior the slice changes. See the \`test-seam\` glossary term for what a seam is.
+
 Guidance for you (not part of the message): Keep one slice ≈ one focused review surface. Delegate slices incrementally — one at a time, not all at once.
 
 \`\`\`\`markdown
@@ -73437,8 +73509,15 @@ Cross-file types, interfaces, or patterns that apply beyond a single file. Omit
 - <verifiable outcome the builder can self-check>
 - Include at least one check that the feature is **verified end-to-end**. Unit tests alone are insufficient for new features.
 
+## Test seams
+- <behavior>: seam <public interface or port>; catches <what>; misses <what>
+- or: no test seam — <reason>
+- For each named seam: write a failing test first, then make it pass (red-green). If the seam is \`no test seam\`, delete this line.
+
 ## What to avoid
 - <anti-patterns, recurring mistakes, or scope creep for this slice — be explicit>
+- Do not test private methods or mock internal collaborators. A test that breaks on refactor while behavior is unchanged is wrong.
+- Do not derive expected values by re-running the code's own formula. Take them from a known-good literal, a worked example, or the spec.
 - <e.g. "Do not add new abstractions", "Do not refactor unrelated files", "Do not change existing public APIs">
 
 ## Skills to activate
@@ -73475,7 +73554,7 @@ var init_planner_game_asset_designer_chat = __esm(() => {
 // ../../services/backend/prompts/teams/researcher-handoff-templates.ts
 function getEntryPointToResearcherHandoffTemplate(query) {
   const entryPoint = query.fromRole;
-  return `The automatically injected \`<user-message>\` is the authoritative request. Pass the decisions the research must ground, the specific research questions, known constraints, and the files or areas already suspected. Ask the researcher for a report only: do not edit files, implement code, or design alternative architectures.
+  return `The automatically injected \`<user-message>\` is the authoritative request. Pass the decisions the research must ground, the specific research questions, known constraints, and the files or areas already suspected. List the domain nouns the research must check for existing equivalents in the repository, and any source the researcher must prefer or avoid. Ask the researcher for a report only: do not edit files, implement code, or design alternative architectures.
 
 ### When to research
 
@@ -73500,7 +73579,7 @@ ${handoffCommand({
 }
 function getResearcherToEntryPointHandoffTemplate(query) {
   const entryPoint = query.toRole;
-  return `Instructions (not part of the message): Return a complete, evidence-backed research brief for the authoritative request. The researcher is advisory: do not edit files, implement code, or present alternative architectures beyond what grounds the decision. Answer only the questions asked. Separate every finding into confirmed (with evidence), inferred (with reasoning), or unknown. Never present a guess as fact. External claims must cite the source URL together with the version or date checked. Use the exact sections below, in this order.
+  return `Instructions (not part of the message): Return a complete, evidence-backed research brief for the authoritative request. The researcher is advisory: do not edit files, implement code, or present alternative architectures beyond what grounds the decision. Answer only the questions asked. Separate every finding into confirmed (with evidence), inferred (with reasoning), or unknown. Never present a guess as fact. External claims must cite the source URL together with the version or date checked. Prefer official documentation and primary sources (the package's own source or changelog, the platform's release notes) over blog posts and summaries; if only a secondary source was found, label the claim as resting on it. Use the exact sections below, in this order.
 
 ## Summary
 <state the answer to the core question in two to four sentences and whether any decision remains open>
@@ -73512,10 +73591,10 @@ function getResearcherToEntryPointHandoffTemplate(query) {
 <one entry per question, each tagged \`confirmed\` (with evidence), \`inferred\` (with reasoning), or \`unknown\`>
 
 ## Repository evidence
-<concrete repository paths and symbols with what each shows; quote the relevant lines briefly>
+<concrete repository paths and symbols with what each shows; quote the relevant lines briefly; before recommending any new library, type, module, or abstraction, search the repository for an existing concept that does the same job under another name (search the domain nouns and their synonyms), and list each match with whether it fits and why>
 
 ## External sources
-<URL, version or date checked, and the specific claim each source supports; write exactly \`None consulted.\` if no external source was needed, and say why>
+<one line per source: URL, the version or date checked, whether it is primary (official documentation, source code, changelog, release notes) or secondary, and the specific claim it supports; write exactly \`None consulted.\` if no external source was needed, and say why>
 
 ## Grounded facts for the plan
 <the facts the planner can rely on when decomposing and delegating, each tagged confirmed or inferred>
@@ -73560,7 +73639,7 @@ var init_planner_researcher_chat = __esm(() => {
 // ../../services/backend/prompts/teams/reviewer-handoff-templates.ts
 function getEntryPointToReviewerHandoffTemplate(query) {
   const entryPoint = query.fromRole;
-  return `Pass the review target and the review focus. State the exact commit range, branch, pull request, or file list to inspect, the focus areas (for example security, correctness, or test quality), and any known context or constraints. Ask the reviewer for a report only: do not edit files, run builds or tests, or implement fixes.
+  return `Pass the review target and the review focus. State the exact commit range, branch, pull request, or file list to inspect, the focus areas (for example security, correctness, or test quality), and any known context or constraints. Name the spec the change must satisfy (the user's request, an issue, or a file under \`docs/\`), or write \`no spec available\` when there is none. Ask the reviewer for a report only: do not edit files, run builds or tests, or implement fixes.
 
 ### When to review
 
@@ -73584,16 +73663,35 @@ ${handoffCommand({
 }
 function getReviewerToEntryPointHandoffTemplate(query) {
   const entryPoint = query.toRole;
-  return `Instructions (not part of the message): Return a complete review report for the target the planner named. The reviewer is advisory: do not edit files, implement fixes, run builds or tests, or propose architecture rewrites beyond each issue's suggested fix. Report only what you observed and mark anything unverified as such. Label every issue with a severity: \`blocker\`, \`major\`, \`minor\`, or \`nit\`. Group the issues by severity with blockers first, and cite the repository-relative file and line or line range for each. Use the exact sections below, in this order.
+  return `Instructions (not part of the message): Return a complete review report for the target the \`${entryPoint}\` named. The reviewer is advisory: do not edit files, implement fixes, run builds or tests, or propose architecture rewrites beyond each issue's suggested fix.
+
+What a good review covers:
+- Read the actual files and the surrounding code the diff depends on, not summaries.
+- Judge the target on three axes: \`standards\` (the repository's documented standards, such as \`CONTRIBUTING.md\`, \`AGENTS.md\`, or \`CLAUDE.md\` when present, and the conventions of the surrounding code; cite the standard by file and rule), \`spec\` (the request, issue, or spec the planner named, recorded in \`## Review scope\`; quote the requirement), and \`defect\` (a demonstrable bug or security flaw, cited by reproduction or code path). Tag every issue with its axis.
+- Cite the repository-relative \`file:line\` or line range for every issue, give the evidence (the quoted line or the code path), and suggest a concrete, small fix.
+- Calibrate severity: \`blocker\` for exposure or modification of another user's data, a broken build, or a violated must-have spec requirement; \`major\` for a real defect or a non-blocking spec miss, including a missing or wrong auth check that exposes no other user's data (the endpoint audit's Reporting rule takes precedence for auth gaps); \`minor\` for a real but low-impact issue; \`nit\` for style only. Group the issues by severity with blockers first.
+- Report only what you observed; mark anything unverified as such and append \`(judgement)\` to a heuristic call that is neither a documented-standard breach nor a \`defect\`.
+- Quote the named spec's requirement for every \`spec\` issue. If no spec was named or found, write \`no spec available\` in \`## Review scope\`; do not invent one.
+- Stay within the stated focus, and do not duplicate issues.
+- Name what you did not check under \`## Not reviewed\`.
+
+Audit authentication and authorization for every backend endpoint in review scope, regardless of the stated focus. An endpoint is any exported Convex query, mutation, or action, HTTP route, or API handler that the target adds or changes, plus any such endpoint the changed code calls or exposes. For each endpoint, check:
+- **Authentication:** the endpoint establishes the caller's identity before it reads or writes data, using the shared auth helper the sibling endpoints use. It does not trust a caller-supplied user id, role, or team id as proof of identity.
+- **Authorization:** the endpoint checks that the authenticated caller may act on the specific resource the request names (for example chatroom membership, ownership, or role) before it returns data or changes state. A login check alone is not sufficient.
+- **Coverage:** no code path returns or changes data before its check runs. An internal helper that skips checks may be called only from endpoints that already performed them.
+- **Intent:** an endpoint without a check is acceptable only when the code or the spec states why it is public. Otherwise report it.
+- **Reporting:** report each missing or wrong check as a \`defect\` axis issue. Use \`blocker\` when it exposes or changes another user's data, and \`major\` otherwise. Cite the endpoint's \`file:line\`; list every in-scope endpoint you did not read under \`## Not reviewed\`.
+
+Use the exact sections below, in this order.
 
 ## Summary
-<one to three sentences: overall state of the target and the count of blocker/major issues>
+<one to three sentences: overall state of the target; the pass/fail result for each of \`standards\`, \`spec\`, and \`defect\`; and the count of blocker/major issues>
 
 ## Review scope
-<commits, paths, and PR/branch inspected; commands run, if any>
+<commits, paths, and PR/branch inspected; the spec source used for the spec axis, or exactly \`no spec available\` when none was named or found; the standards files read; commands run, if any>
 
 ## Issues
-<numbered list grouped by severity (blocker, major, minor, nit); each item: \`file:line\` — summary — evidence — suggested fix; write exactly \`None observed.\` if none>
+<numbered list grouped by severity (blocker, major, minor, nit); each item: severity, axis (\`standards\`, \`spec\`, or \`defect\`), \`file:line\` — summary — evidence — suggested fix; append \`(judgement)\` to the summary when the issue is a heuristic call; write exactly \`None observed.\` if none>
 
 ## Not reviewed
 <anything out of scope or unreadable; write exactly \`None.\` if none>
@@ -73629,7 +73727,7 @@ var init_planner_reviewer_chat = __esm(() => {
 // ../../services/backend/prompts/teams/triage-handoff-templates.ts
 function getEntryPointToTriageHandoffTemplate(query) {
   const entryPoint = query.fromRole;
-  return `The automatically injected \`<user-message>\` is the authoritative request. Pass the reported bug, observed and expected behavior, reproduction details and commands, relevant constraints, and the files or symbols already suspected. Ask triage to investigate and report only. Triage may inspect code and attempt a focused automated regression test as evidence, but must not edit implementation files or implement a fix.
+  return `The automatically injected \`<user-message>\` is the authoritative request. Pass the reported bug, observed and expected behavior with the source of the expectation (the reporter's words, a spec, or a documented decision), reproduction details and commands, relevant constraints, and the files or symbols already suspected. State the observable success condition: what the fixed behavior looks like to the reporter, so triage can build a loop that goes red on this bug and green once it is fixed. Ask triage to investigate and report only. Triage may inspect code and attempt a focused automated regression test as evidence, but must not edit implementation files or implement a fix.
 
 Use this for every reported bug (something broken or behaving differently than expected) before any fix is implemented.
 
@@ -73646,7 +73744,7 @@ ${handoffCommand({
 }
 function getTriageToEntryPointHandoffTemplate(query) {
   const entryPoint = query.toRole;
-  return `Instructions (not part of the message): Return a complete, evidence-backed investigation of the authoritative reported bug. Triage is advisory: do not edit implementation files or implement the proposed fix. Begin with the \`## Summary\` section, then use the remaining sections below in order. Use \`###\` for sub-items within a section. Cite concrete repository paths and symbols, observed behavior, commands, and test output. Distinguish confirmed findings from hypotheses; never claim a test proved behavior unless its failing assertion demonstrates the report.
+  return `Instructions (not part of the message): Return a complete, evidence-backed investigation of the authoritative reported bug. Triage is advisory: do not edit implementation files or implement the proposed fix. Begin with the \`## Summary\` section, then use the remaining sections below in order. Use \`###\` for sub-items within a section. Cite concrete repository paths and symbols, observed behavior, commands, and test output. Distinguish confirmed findings from hypotheses; never claim a test proved behavior unless its failing assertion demonstrates the report. Redact every secret in quoted output as \`<REDACTED>\`, and quote only the lines that carry the signal.
 
 ## Summary
 <briefly state the diagnosis and whether the root cause was confirmed or remains a hypothesis>
@@ -73655,13 +73753,13 @@ function getTriageToEntryPointHandoffTemplate(query) {
 <state the reported symptoms and expected behavior, including reproduction details and constraints recovered from the request or relevant history>
 
 ## Root cause
-<trace the relevant ownership, data, and control flow using concrete repository paths and symbols; explain the causal reasoning and explicitly label the finding as confirmed or a hypothesis>
+<first list 3 to 5 ranked hypotheses, or fewer when a stack trace or failing assertion already pins the cause, each as "If <X> is the cause, then <changing Y> removes the symptom (or <changing Z> makes it worse)", before testing any of them; then state the confirmed or hypothesized cause, tracing ownership, data, and control flow with concrete repository paths and symbols; for each hypothesis, say whether it was tested and the outcome; check decision records under \`memory/\` (start at \`memory/index.md\`) and docs/ for whether the behavior is documented as intended before calling it a defect; label the finding confirmed or hypothesis>
 
 ## Reproduction attempt
-<give the focused test path and exact command, the failing assertion or exact blocker, and the outcome; if reproduction was blocked, state what was tried and what additional information would help; do not fabricate proof>
+<give the one command that drives the user's exact symptom, its observed output (redacted), and whether it is deterministic; when cheap and safe, record the run count, flake rate, and performance baseline; give the minimal scenario, listing each input, caller, or configuration removed and whether the symptom stayed; if a regression test was written, its path, command, and failing assertion; if no reproducing command could be built, say so, list what was tried, and name exactly what is needed to proceed (environment access, a redacted captured artifact, or permission to add temporary instrumentation); never fabricate proof>
 
 ## Proposed immediate fix
-<recommend the smallest appropriate change, naming the likely files and the specific change; do not implement it>
+<recommend the smallest appropriate change, naming the likely files and the specific change; do not implement it; then name the regression-test seam. A test seam is the public interface where a test observes behavior. Substitution in a test is allowed only at a port or adapter boundary (an external dependency injected through a port). Do not mock internal collaborators. Give one line on what the seam catches and what it misses; if only a shallow seam exists (the bug needs several callers or a longer chain of calls to trigger), say so and add it under Systemic issues>
 
 ## Systemic issues
 <list each separate systemic concern with repository evidence, impact, and follow-up concern, or write exactly: None observed.>
@@ -75045,6 +75143,14 @@ var init_data_design = () => {};
 
 // ../../services/backend/src/domain/usecase/skills/modules/defragmentation/index.ts
 var init_defragmentation = () => {};
+
+// ../../services/backend/src/domain/usecase/skills/modules/game-asset-2d-ai/index.ts
+var init_game_asset_2d_ai = () => {};
+// ../../services/backend/src/domain/usecase/skills/modules/game-asset-3d-ai/index.ts
+var init_game_asset_3d_ai = () => {};
+
+// ../../services/backend/src/domain/usecase/skills/modules/game-asset-3d-procedural/index.ts
+var init_game_asset_3d_procedural = () => {};
 // ../../services/backend/src/domain/usecase/skills/modules/user-centricity/index.ts
 var init_user_centricity = () => {};
 
@@ -75054,6 +75160,9 @@ var init_registry3 = __esm(() => {
   init_code_review();
   init_data_design();
   init_defragmentation();
+  init_game_asset_2d_ai();
+  init_game_asset_3d_ai();
+  init_game_asset_3d_procedural();
   init_user_centricity();
 });
 
@@ -75107,6 +75216,10 @@ var init_glossary = __esm(() => {
     {
       term: "structural-decisions",
       definition: "Meta-level architectural choices that persist in the codebase and influence consistency: " + "folder structure, file naming, interface definitions, and key abstraction names/locations " + "(e.g., Repository/Service layers)."
+    },
+    {
+      term: "test-seam",
+      definition: "The public interface where a test observes behavior. Substitution in a test is allowed only at a port or adapter boundary (an external dependency injected through a port); do not mock internal collaborators."
     }
   ];
   NATIVE_GLOSSARY_TERMS = [
@@ -75229,12 +75342,20 @@ var init_game_asset_designer2 = __esm(() => {
   init_sections();
   GAME_ASSET_DESIGNER_GUIDANCE = `## Game Asset Designer Operating Model
 
-You specify and generate production-quality game and UI assets (generation is the default unless the brief says \`spec only\`), using \`chatroom generate-image --platform=fal\` for 2D assets and \`chatroom generate-3d --platform=fal\` for 3D models. A 3D run writes \`<base>.zip\` (contents: R1) and \`<base>.html\`, a separate preview of the web variant; \`<base>\` is the \`--out\` stem plus the run's UTC timestamp, and \`--package-dir <dir>\` (default: the master's directory) moves both. You are not the builder or planner; do not implement application logic outside the asset-integration paths the brief allows. Your delivery report uses Proof of Principles and Proof of Completion.
+You specify and generate production-quality game and UI assets (generation is the default unless the brief says \`spec only\`). You use the matching skill for every generation step. You are not the builder or planner; do not implement application logic outside the asset-integration paths the brief allows. Your delivery report uses Proof of Principles and Proof of Completion.
 
 ${"{SESSION_CONTINUITY}"}
 
 ${getInterRoleHandoffRule()}
 
+### Skills
+Activate exactly the skill that matches each asset, using the command form for this chatroom and role:
+- 3D asset via AI generation → \`game-asset-3d-ai\`: \`chatroom skill activate game-asset-3d-ai --chatroom-id=<chatroom-id> --role=game-asset-designer\`
+- 2D asset via AI generation → \`game-asset-2d-ai\`: \`chatroom skill activate game-asset-2d-ai --chatroom-id=<chatroom-id> --role=game-asset-designer\`
+- 3D asset via a committed procedural generator → \`game-asset-3d-procedural\`: \`chatroom skill activate game-asset-3d-procedural --chatroom-id=<chatroom-id> --role=game-asset-designer\`
+
+A brief that mixes asset types activates each skill it needs. Audio and non-game UI icons are not covered by these skills; for audio, apply the All assets and Audio checklists in this prompt.
+
 ### RULES
 ${formatGameAssetRules()}
 
@@ -75243,16 +75364,13 @@ ${GAME_ASSET_EVIDENCE_DEFINITIONS}
 ${GAME_ASSET_NEVER_CLAIM_RULE} ${GAME_ASSET_RESULT_RULE}
 
 ### PROCEDURE
-P1 Recover the brief. IF engine, tier, style, or budgets are missing and the repo cannot answer THEN ask \`{ENTRY_POINT_ROLE}\` (Summary "Blocked:", unreached "Not started") ELSE defaults+assumptions.
+P1 Recover the brief. IF \`## Lighting contract\` is missing, not specified, or not applicable for a 3D asset, or engine, tier, style, or budgets are missing and the repo cannot answer, THEN ask \`{ENTRY_POINT_ROLE}\` (Summary "Blocked:", unreached "Not started"); ELSE apply defaults+assumptions (\`Not applicable.\` only for 2D/audio).
 P2 Inspect assets, names, folders, engine config; cite paths.
 P3 Classify each asset; one manifest entry per ID (\`A01\`…).
-P4 IF \`Deliverable mode\` = \`spec only\` OR \`Output location\`/\`Allowed tools\` missing/ambiguous THEN no files, deliver \`Specified only.\`, GOTO P10.
-P5 IF the asset is 3D THEN \`generate-3d --platform=fal --model <Model>\` (\`--prompt\`/\`--input-image\`, \`--out <Output location>/<ascii-name>.glb\`, \`--rig\`/\`--animation-action-id\` only as R1 allows (approval quoted)), GOTO P9. ELSE Count N. IF N=1 or styles differ THEN per-asset \`generate-image\`, GOTO P8. ELSE use ceil(N / (C×R)) sheets of ≤(C×R) items per \`Sheet grid\` (2x2 default). Prompt: one item per cell, CxR grid, no lines/borders/frames/duplicates. Generate \`generate-image --platform=fal --model <Model> --prompt "<prompt>" --out <Output location>/_work/<sheet>.png\`.
-P6 \`chatroom slice-image --in <sheet> --out-dir <Output location>/_work/tiles --cols C --rows R\`. IF refused regenerate once; IF still refused one \`generate-image\` per asset (P5).
-P7 View each tile. IF any tile has 0/2+ items, a cut item, or count differs from the brief's requested count (extra cells OK) THEN regenerate once; IF still bad THEN one \`generate-image\` per asset (P5). Name from sight.
-P8 IF \`remove-image-background --help\` succeeds THEN run \`remove-image-background --in-dir <tiles> --out-dir <Output location> --map <stem>=<name>,... --trim\` (single: \`--in <image> --out <Output location>/<name>.png --trim\`); view results. IF warnings/halo THEN rerun with \`--tolerance\`/\`--force\` max twice, ELSE accept. ELSE rerun \`slice-image --names\`; record trimming not delivered as a failed item/open question.
-P9 Record model, seed, manifests, names.
-P10 Apply checklist, label evidence, fill proofs.
+P4 IF existing assets and an asset-in-rig render are named THEN skip P5–P9 (no generation, slicing, or packaging), apply only the lighting item in this prompt's All assets checklist, GOTO P10. IF \`Deliverable mode\` = \`spec only\` OR \`Output location\`/\`Allowed tools\` missing THEN deliver \`Specified only.\`, lighting \`n/a\`, GOTO P10.
+P5 Generate: activate the matching skill and follow its generation procedure for each asset type; never use a generator the brief does not name.
+P9 Record the model or generator and tool, the seed or parameter set, the manifests, and the names.
+P10 Apply checklist, label evidence, fill proofs; apply the lighting item (\`n/a\` for \`spec only\`); if \`not checked\`, deliver as \`Delivered, lighting not verified:\`.
 P11 Hand off to \`{ENTRY_POINT_ROLE}\`, then stop.
 
 ### Quality checklist (apply to each asset; mark each item pass, fail, or not applicable, with its evidence label)
@@ -75262,43 +75380,15 @@ P11 Hand off to \`{ENTRY_POINT_ROLE}\`, then stop.
 - File format is the one the target engine imports (glTF 2.0/GLB, FBX, PNG, WAV/OGG as named in the request); no unused data (hidden meshes, unused materials, history).
 - Style matches the named style reference: silhouette, value range, palette, level of detail, and texel density or pixel grid.
 - Budgets in the request are met; any exceedance is called out with the measured value.
-
-**3D models**
-- Units and axes match the target (glTF: meters, +Y up, front +Z); scale is applied (identity scale) and a real-world size is stated.
-- Pivot/origin follows the declared policy; LODs share the base pivot and alignment.
-- Clean topology: no n-gons or non-manifold edges unless declared, no flipped normals or inverted winding (glTF: counter-clockwise front faces), consistent normals and tangents (MikkTSpace).
-- Triangle count per LOD is within budget; LOD naming matches the engine (Unity \`_LOD0\`, \`_LOD1\`; Unreal LODs share the base pivot and alignment and are imported per the FBX import options; Godot generates LODs at import, so declare the Generate LODs setting instead of a suffix).
-- UVs: non-overlapping unique layout where textures are unique, island padding, consistent texel density, no stretched islands; a second UV set if the engine needs baked lighting.
-- Collision and sockets use the engine's naming (Unreal \`UBX_\`/\`UCP_\`/\`USP_\`/\`UCX_\` + mesh name and \`SOCKET_\` + mesh name; Godot \`-col\`/\`-convcolonly\` suffixes).
-- Skinned meshes: bone count within budget, influences per vertex within the declared budget (commonly 4, marked \`unverified\`; glTF allows more via \`JOINTS_1\`), no leftover IK helpers, a named rest pose.
-
-**PBR materials and textures**
-- Metallic-roughness workflow with documented channel packing (glTF: roughness in G, metallic in B, occlusion in R).
-- Color space: base color and emissive sRGB; normal, roughness, metallic, occlusion, masks linear. State the normal map Y convention. In glTF, color space is set by the material slot that references the image, not by embedded PNG chunks. Verify the slot for each map: \`baseColorTexture\` and \`emissiveTexture\` are sRGB; \`metallicRoughnessTexture\`, \`occlusionTexture\` and \`normalTexture\` are linear.
-- Base color values stay in a physically plausible range (community starting range roughly 30–240 sRGB per channel for non-metals; the request's budget overrides it); metallic is near binary.
-- Resolution matches the texel-density budget and surface size; dimensions meet the engine/platform rule (power of two where the engine needs mipmaps or streaming, for example Unreal; confirm for the target engine version); compression format named.
-- Tiling textures wrap without a visible seam; no baked-in lighting or text in base color unless declared.
-- Maps in one set share texel density, value range, and naming (\`T_Name_BaseColor\`, \`_Normal\`, \`_ORM\`).
-
-**2D sprites and UI art**
-- Fixed grid and pixels-per-unit declared; sprite sizes are multiples of the grid; no sub-pixel offsets.
-- Palette size and colors declared; transparent background with clean alpha edges.
-- Animation: uniform frame size per clip, frame count, frame rate, loop flag, and pivot per clip.
-- Atlas: padding of at least the engine default (Unity default 4 px), atlas size within the platform max, filter mode Point for pixel art and no mip maps.
-- Export PNG (lossless with alpha); name states size and frame count where relevant.
-- Camera perspective matches the perspective chosen for the set (the brief's \`Perspective\`, or the one recorded under assumptions) and every other asset in the set (compare them side by side); \`n/a\` for a single asset.
+- **Lighting**: renders correctly under the brief's \`## Lighting contract\` (visible, coloured and textured, not near-black). Pass needs the asset-in-rig render under \`## Lighting verification\`; the rig reference render and Studio mode never support pass.
 
 **Audio**
-- Loudness measured against the platform target stated in the request (for example console -24 LUFS, mobile -18 LUFS, true peak at or below -1 dBTP); no clipping. Measure with a tool: \`ffmpeg -i <file> -af ebur128=peak=true -f null -\` for integrated loudness and true peak; \`ffprobe <file>\` for sample rate, bit depth and channels; for glTF, \`gltf-transform inspect <file>\` (quote the command's actual output). Cite the platform source. If the request does not state the target, mark the loudness target \`unverified\` and name the source. Mobile targets vary (-18 vs -16 LUFS).
+- Loudness measured against the platform target stated in the request (for example console -24 LUFS, mobile -18 LUFS, true peak at or below -1 dBTP); no clipping. Measure with a tool: \`ffmpeg -i <file> -af ebur128=peak=true -f null -\` for integrated loudness and true peak; \`ffprobe <file>\` for sample rate, bit depth and channels. Quote the command's actual output. Cite the platform source. If the request does not state the target, mark the loudness target \`unverified\` and name the source. Mobile targets vary (-18 vs -16 LUFS).
 - Sample rate, bit depth, channel count, loop points, and format stated; short noisy SFX use PCM or ADPCM, long audio uses compressed or streamed formats, per the engine's guidance.
 
-### Perspective consistency (generated 2D sets)
-Assets used together must share one camera perspective. The model's constraints (unsupported parameters, size defaults, what it does not guarantee) come only from the matching \`--dry-run\` (R16) — \`generate-image --dry-run\` for a 2D asset and \`generate-3d --dry-run\` for a 3D model; apply them, and never add a parameter the dry run reports as unsupported.
-- Repeat the perspective term from the brief's \`Perspective\` word for word in every prompt of the set (never the \`reference:\` path), and add the same flattening terms to every prompt: \`flat 2D game asset, orthographic, centered, plain background, even lighting\`. Suggested perspective terms (\`unverified\`): side view, front view, orthographic top-down, orthographic isometric, dimetric 2:1, three-quarter view. If the field names only a reference, describe that reference's view in words and record the description under assumptions. If \`Perspective\` is \`Not specified.\`, pick one, record it under assumptions, and use it for the whole set. If the \`Style reference\` asks for a lighting style these terms contradict (for example dramatic lighting), keep the perspective term and drop only the conflicting flattening term.
-- Use one \`--input\` JSON (from \`Model parameters\`) on every call of the set; if the dry run reports a size parameter as defaulted, set it once in that JSON and reuse it. Add \`--input '<JSON>'\` and the seed to every P5 command.
-- Use one shared \`--seed\` for the first call of each item or sheet. For every regeneration (P6, P7, or a perspective mismatch), use a new seed and record it (P9). A shared seed does not keep perspective across different prompts.
-- Pass \`--input-image <path>\` with \`--model fal-ai/flux-2/flash/edit\` only when the brief's \`Model\` is \`fal-ai/flux-2/flash/edit\` and \`Perspective\` names a reference path. In this mode generate every asset individually (the P5 per-asset path, one \`--input-image\` per asset); never use a sheet.
-- Inspect the set side by side. A mismatched item is regenerated individually (the P5 per-asset path, with a new seed), at most twice per item, separately from the sheet regenerations of P6 and P7. If it still differs, mark the perspective checklist item \`fail\` with \`inspected\` evidence.
+### Set consistency principles
+- **One camera perspective per set.** Repeat the perspective term from the brief's \`## Perspective\` word for word in every prompt of the set; \`n/a\` for 3D models and audio. The matching skill owns the full perspective rules.
+- **One lighting and palette anchor per set.** From the brief's \`## Lighting contract\` and \`## Style reference\`, choose one anchor (palette, light direction, colour temperature, background, material treatment) and repeat it word for word in every prompt of the set. If the contract and the style reference conflict, follow the contract and record the deviation under assumptions. The matching skill owns the full anchor rules.
 
 ### Scope boundary
 You may specify, name, organize, generate, validate, and integrate assets within the paths the brief allows. You must not claim fidelity you did not establish. If you cannot open or measure a file, write \`unverified\`. Do not present alternative art directions beyond what the request needs; recommend one.
@@ -75332,7 +75422,7 @@ ${getInterRoleHandoffRule()}
 
 1. Recover the authoritative request and the research questions from the injected task and chatroom history. If the questions are not explicit, derive the decisions the planner must make and answer those.
 2. Investigate the repository first: existing modules, APIs, types, patterns, tests, and conventions that bear on the request. Cite concrete paths and symbols.
-3. Investigate external sources when the request depends on libraries, APIs, platform behavior, versions, or recent changes. Prefer official documentation and primary sources. Record the URL, the version, and the date checked.
+3. Investigate external sources when the request depends on libraries, APIs, platform behavior, versions, or recent changes. Prefer official documentation and primary sources (the package's own source or changelog, the platform's release notes). Record the URL, the version, and the date checked.
 4. Label every finding \`confirmed\`, \`inferred\`, or \`unknown\`. Never present a guess as fact.
 5. Resolve ambiguity where evidence allows. For the rest, state the open question, who must decide it, and a recommended default.
 6. Follow the injected \`<handoff-templates>\` research brief exactly, in its order. Answer only the questions asked. Do not present alternative architectures beyond what grounds the decision.
@@ -75358,9 +75448,15 @@ ${getInterRoleHandoffRule()}
 1. Recover the review target and focus from the injected task and the \`<handoff-templates>\` brief. If the target is not explicit, ask the planner through the handoff; do not guess a range.
 2. Inspect the target: the diff or commits, the changed files, and the surrounding code they depend on. Read the actual files; do not review from summaries.
 3. Look for correctness bugs, security issues, missing or weak tests, unclear ownership or error handling, dead code, duplication, and type drift. Stay within the stated focus when one is given.
-4. Label every issue with a severity (\`blocker\`, \`major\`, \`minor\`, \`nit\`) and cite the file and line. Only report what you observed; mark anything unverified as such.
-5. Follow the injected \`<handoff-templates>\` review report exactly, in its order.
-6. Hand the report to \`{ENTRY_POINT_ROLE}\` with the normal command, then stop:
+4. Audit authentication and authorization for every backend endpoint in review scope. An endpoint is any exported Convex query, mutation, or action, HTTP route, or API handler that the target adds or changes, plus any such endpoint the changed code calls or exposes. For each endpoint, check:
+   - **Authentication:** the endpoint establishes the caller's identity before it reads or writes data, using the shared auth helper the sibling endpoints use. It does not trust a caller-supplied user id, role, or team id as proof of identity.
+   - **Authorization:** the endpoint checks that the authenticated caller may act on the specific resource the request names (for example chatroom membership, ownership, or role) before it returns data or changes state. A login check alone is not sufficient.
+   - **Coverage:** no code path returns or changes data before its check runs. An internal helper that skips checks may be called only from endpoints that already performed them.
+   - **Intent:** an endpoint without a check is acceptable only when the code or the spec states why it is public. Otherwise report it.
+   Report each missing or wrong check as a \`defect\` axis issue. Use severity \`blocker\` when the gap exposes or changes another user's data, and \`major\` otherwise. Cite the endpoint's file and line. List any endpoint in scope that you did not read under \`## Not reviewed\`.
+5. Label every issue with a severity (\`blocker\`, \`major\`, \`minor\`, \`nit\`) and cite the file and line. Only report what you observed; mark anything unverified as such.
+6. Follow the injected \`<handoff-templates>\` review report exactly, in its order.
+7. Hand the report to \`{ENTRY_POINT_ROLE}\` with the normal command, then stop:
 
 \`\`\`bash
 chatroom handoff --chatroom-id="<chatroom-id>" --role="reviewer" --next-role="{ENTRY_POINT_ROLE}"
@@ -75381,7 +75477,7 @@ ${getInterRoleHandoffRule()}
 
 1. Recover the reported bug from the injected task and chatroom history: the observed behavior, the expected behavior, and any reproduction details. If the expected behavior is not explicit, state the assumption you made.
 2. Trace the relevant code paths with concrete repository paths and symbols. Label every finding \`confirmed\` or \`hypothesis\`. Never present a hypothesis as fact.
-3. Attempt a focused reproduction only when it is cheap and safe. A focused regression test may be written as evidence. Do not edit implementation files.
+3. Attempt a focused reproduction, and when cheap and safe, record the run count, flake rate, and performance baseline. A focused regression test may be written as evidence. Do not edit implementation files.
 4. Write the report using the sections in the injected \`<handoff-templates>\`, in the order given, beginning with the \`## Summary\` section.
 5. Hand the report to \`{ENTRY_POINT_ROLE}\` with the normal command, then stop:
 
@@ -75748,6 +75844,218 @@ var init_generator = __esm(() => {
   init_review_guidelines();
 });
 
+// ../shared/src/domain/file-attachment.ts
+function basenameOf(path2) {
+  return path2.split(PATH_SEPARATOR_PATTERN).pop() ?? "";
+}
+function hasForbiddenFilenameCharacter(filename) {
+  return INVALID_FILENAME_CHARACTER_PATTERN.test(filename) || BIDI_CONTROL_CHARACTER_PATTERN.test(filename);
+}
+function resolveFileAttachmentType(filename) {
+  const basename7 = basenameOf(filename);
+  const dotIndex = basename7.lastIndexOf(".");
+  if (dotIndex <= 0)
+    return null;
+  const mimeType = EXTENSION_TO_MIME_TYPE.get(basename7.slice(dotIndex).toLowerCase());
+  if (!mimeType)
+    return null;
+  const info = FILE_ATTACHMENT_TYPES[mimeType];
+  return { mimeType, previewKind: info.previewKind, activeContent: info.activeContent };
+}
+function isValidAttachmentFilename(filename) {
+  return filename.length > 0 && filename.length <= FILE_ATTACHMENT_MAX_FILENAME_LENGTH && !RESERVED_FILENAME_PATTERN.test(filename) && !hasForbiddenFilenameCharacter(filename);
+}
+var FILE_ATTACHMENT_MAX_BYTES, FILE_ATTACHMENT_MAX_PER_HANDOFF = 10, FILE_ATTACHMENT_MAX_FILENAME_LENGTH = 255, FILE_ATTACHMENT_THUMBNAIL_AUTOLOAD_MAX_BYTES, FILE_ATTACHMENT_TYPES, FILE_ATTACHMENT_MIME_TYPES, EXTENSION_TO_MIME_TYPE, INVALID_FILENAME_CHARACTER_PATTERN, BIDI_CONTROL_CHARACTER_PATTERN, PATH_SEPARATOR_PATTERN, RESERVED_FILENAME_PATTERN;
+var init_file_attachment = __esm(() => {
+  FILE_ATTACHMENT_MAX_BYTES = 10 * 1024 * 1024;
+  FILE_ATTACHMENT_THUMBNAIL_AUTOLOAD_MAX_BYTES = 2 * 1024 * 1024;
+  FILE_ATTACHMENT_TYPES = {
+    "image/png": { extensions: [".png"], previewKind: "image", activeContent: false },
+    "image/jpeg": { extensions: [".jpg", ".jpeg"], previewKind: "image", activeContent: false },
+    "image/gif": { extensions: [".gif"], previewKind: "image", activeContent: false },
+    "image/webp": { extensions: [".webp"], previewKind: "image", activeContent: false },
+    "image/svg+xml": { extensions: [".svg"], previewKind: "image", activeContent: true },
+    "application/pdf": { extensions: [".pdf"], previewKind: "pdf", activeContent: false },
+    "text/plain": { extensions: [".txt", ".log"], previewKind: "text", activeContent: false },
+    "text/markdown": { extensions: [".md"], previewKind: "markdown", activeContent: false },
+    "text/csv": { extensions: [".csv"], previewKind: "text", activeContent: false },
+    "application/json": { extensions: [".json"], previewKind: "text", activeContent: false },
+    "text/html": { extensions: [".html", ".htm"], previewKind: "text", activeContent: true },
+    "application/zip": { extensions: [".zip"], previewKind: "download", activeContent: false }
+  };
+  FILE_ATTACHMENT_MIME_TYPES = Object.keys(FILE_ATTACHMENT_TYPES);
+  EXTENSION_TO_MIME_TYPE = new Map(Object.entries(FILE_ATTACHMENT_TYPES).flatMap(([mimeType, info]) => info.extensions.map((extension2) => [
+    extension2.toLowerCase(),
+    mimeType
+  ])));
+  INVALID_FILENAME_CHARACTER_PATTERN = /[/\\\u0000-\u001f\u007f]/;
+  BIDI_CONTROL_CHARACTER_PATTERN = /[\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/;
+  PATH_SEPARATOR_PATTERN = /[/\\]/;
+  RESERVED_FILENAME_PATTERN = /^\.{1,2}$/;
+});
+
+// src/commands/handoff/deps.ts
+var FileAttachmentUploadError;
+var init_deps3 = __esm(() => {
+  FileAttachmentUploadError = class FileAttachmentUploadError extends Error {
+    code;
+    httpStatus;
+    constructor(args2) {
+      super(args2.message);
+      this.name = "FileAttachmentUploadError";
+      this.code = args2.code;
+      this.httpStatus = args2.httpStatus;
+    }
+  };
+});
+
+// src/commands/handoff/attachments.ts
+import { readFile as readFile12, stat as stat8 } from "node:fs/promises";
+import { basename as basename7 } from "node:path";
+function attachmentInvalid(path2, reason) {
+  return { _tag: "AttachmentInvalid", path: path2, reason };
+}
+function uploadFailed(filename, cause) {
+  if (cause instanceof FileAttachmentUploadError) {
+    return {
+      _tag: "AttachmentUploadFailed",
+      filename,
+      code: cause.code,
+      message: cause.message
+    };
+  }
+  return {
+    _tag: "AttachmentUploadFailed",
+    filename,
+    code: "UPLOAD_FAILED",
+    message: cause instanceof Error ? cause.message : String(cause)
+  };
+}
+function validateFileStats(path2, stats) {
+  if (!stats.isFile()) {
+    return exports_Effect.fail(attachmentInvalid(path2, "not a regular file"));
+  }
+  if (stats.size <= 0) {
+    return exports_Effect.fail(attachmentInvalid(path2, "file is empty"));
+  }
+  if (stats.size > FILE_ATTACHMENT_MAX_BYTES) {
+    return exports_Effect.fail(attachmentInvalid(path2, `file exceeds the ${FILE_ATTACHMENT_MAX_BYTES}-byte limit`));
+  }
+  return exports_Effect.void;
+}
+function resolveAttachmentType(path2, filename) {
+  const type = resolveFileAttachmentType(filename);
+  if (!type) {
+    return exports_Effect.fail(attachmentInvalid(path2, "file type is not allowed"));
+  }
+  if (!isValidAttachmentFilename(filename)) {
+    return exports_Effect.fail(attachmentInvalid(path2, "filename is not valid"));
+  }
+  return exports_Effect.succeed(type.mimeType);
+}
+function prepareOneAttachment(path2) {
+  return exports_Effect.gen(function* () {
+    const filename = basename7(path2);
+    const stats = yield* exports_Effect.tryPromise({
+      try: () => stat8(path2),
+      catch: () => attachmentInvalid(path2, "file does not exist or cannot be read")
+    });
+    yield* validateFileStats(path2, stats);
+    const mimeType = yield* resolveAttachmentType(path2, filename);
+    return { path: path2, filename, sizeBytes: stats.size, mimeType };
+  });
+}
+function validateAttachmentEnvelope(paths, nextRole) {
+  const normalizedNextRole = nextRole.toLowerCase();
+  if (normalizedNextRole !== "user") {
+    return exports_Effect.fail({ _tag: "AttachmentsRequireUserTarget" });
+  }
+  if (paths.length > FILE_ATTACHMENT_MAX_PER_HANDOFF) {
+    return exports_Effect.fail({
+      _tag: "AttachmentLimitExceeded",
+      max: FILE_ATTACHMENT_MAX_PER_HANDOFF,
+      count: paths.length
+    });
+  }
+  return exports_Effect.void;
+}
+function prepareHandoffAttachments(paths, nextRole) {
+  return exports_Effect.gen(function* () {
+    if (paths.length === 0)
+      return [];
+    yield* validateAttachmentEnvelope(paths, nextRole);
+    const prepared = [];
+    for (const path2 of paths) {
+      prepared.push(yield* prepareOneAttachment(path2));
+    }
+    return prepared;
+  });
+}
+function discardHandoffAttachments(uploader, sessionId, attachmentIds) {
+  if (attachmentIds.length === 0)
+    return exports_Effect.void;
+  return exports_Effect.tryPromise({
+    try: () => uploader.discardUploads({ sessionId, attachmentIds: [...attachmentIds] }),
+    catch: () => {
+      return;
+    }
+  }).pipe(exports_Effect.catch(() => exports_Effect.void));
+}
+function uploadOneFile(uploader, args2, file2) {
+  return exports_Effect.gen(function* () {
+    const bytes = yield* exports_Effect.tryPromise({
+      try: () => readFile12(file2.path),
+      catch: (cause) => uploadFailed(file2.filename, cause)
+    });
+    if (bytes.length > FILE_ATTACHMENT_MAX_BYTES) {
+      return yield* exports_Effect.fail(attachmentInvalid(file2.path, `file exceeds the ${FILE_ATTACHMENT_MAX_BYTES}-byte limit`));
+    }
+    if (bytes.length !== file2.sizeBytes) {
+      return yield* exports_Effect.fail(attachmentInvalid(file2.path, "file changed while it was being read"));
+    }
+    const begun = yield* exports_Effect.tryPromise({
+      try: () => uploader.beginUpload({
+        sessionId: args2.sessionId,
+        chatroomId: args2.chatroomId,
+        senderRole: args2.senderRole,
+        filename: file2.filename,
+        sizeBytes: bytes.length
+      }),
+      catch: (cause) => uploadFailed(file2.filename, cause)
+    });
+    yield* exports_Effect.tryPromise({
+      try: () => uploader.uploadBytes({
+        sessionId: args2.sessionId,
+        attachmentId: begun.attachmentId,
+        uploadUrl: begun.uploadUrl,
+        bytes
+      }),
+      catch: (cause) => uploadFailed(file2.filename, cause)
+    }).pipe(exports_Effect.tapError(() => discardHandoffAttachments(uploader, args2.sessionId, [begun.attachmentId])));
+    return begun.attachmentId;
+  });
+}
+function uploadHandoffAttachments(uploader, args2) {
+  return exports_Effect.gen(function* () {
+    const uploadedIds = [];
+    const uploadAll = exports_Effect.gen(function* () {
+      for (const file2 of args2.files) {
+        uploadedIds.push(yield* uploadOneFile(uploader, args2, file2));
+      }
+    });
+    yield* uploadAll.pipe(exports_Effect.catch((error51) => exports_Effect.gen(function* () {
+      yield* discardHandoffAttachments(uploader, args2.sessionId, uploadedIds);
+      return yield* exports_Effect.fail(error51);
+    })));
+    return uploadedIds;
+  });
+}
+var init_attachments = __esm(() => {
+  init_file_attachment();
+  init_dist();
+  init_deps3();
+});
+
 // src/infrastructure/cli-gateway/local-handoff-gateway.ts
 function createLocalHandoffGateway() {
   return {
@@ -75781,6 +76089,113 @@ var init_create_convex_command_deps = __esm(() => {
   init_client2();
 });
 
+// src/infrastructure/file-attachments/convex-file-attachment-uploader.ts
+function createConvexFileAttachmentUploader(backend2, fetchFn = fetch) {
+  const backendUrl = getConvexUrl();
+  return {
+    beginUpload: async (args2) => {
+      const result3 = await backend2.mutation(api.fileAttachments.beginUpload, args2);
+      return {
+        attachmentId: result3.attachmentId,
+        uploadUrl: result3.uploadUrl
+      };
+    },
+    uploadBytes: async ({ sessionId, attachmentId, uploadUrl, bytes }) => {
+      assertUploadUrlAllowed(uploadUrl, backendUrl);
+      const response = await fetchFn(uploadUrl, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${sessionId}`,
+          [ATTACHMENT_ID_HEADER]: attachmentId,
+          "Content-Type": "application/octet-stream",
+          "Content-Length": String(bytes.byteLength)
+        },
+        body: bytes
+      });
+      if (response.ok)
+        return;
+      const { code: code2, message } = await readUploadError(response);
+      throw new FileAttachmentUploadError({ code: code2, message, httpStatus: response.status });
+    },
+    discardUploads: async ({ sessionId, attachmentIds }) => {
+      await backend2.mutation(api.fileAttachments.discardUploads, { sessionId, attachmentIds });
+    }
+  };
+}
+function rejectedUploadUrl(message) {
+  return new FileAttachmentUploadError({
+    code: REJECTED_UPLOAD_URL_CODE,
+    message,
+    httpStatus: 0
+  });
+}
+function isLoopbackHostname(hostname5) {
+  return hostname5 === "localhost" || hostname5 === "127.0.0.1" || hostname5 === "[::1]";
+}
+function isConvexLocalSitePort(uploadPort, backendPort) {
+  return uploadPort !== "" && backendPort !== "" && Number(uploadPort) === Number(backendPort) + 1;
+}
+function parseUploadUrl(uploadUrl, backendUrl) {
+  try {
+    return { upload: new URL(uploadUrl), backend: new URL(backendUrl) };
+  } catch {
+    throw rejectedUploadUrl("Upload URL is not a valid URL");
+  }
+}
+function isSupportedUploadProtocol(protocol4) {
+  return protocol4 === "http:" || protocol4 === "https:";
+}
+function requiresHttps(upload) {
+  return upload.protocol === "http:" && !isLoopbackHostname(upload.hostname);
+}
+function assertUploadProtocol(upload) {
+  if (!isSupportedUploadProtocol(upload.protocol)) {
+    throw rejectedUploadUrl(`Upload URL uses an unsupported protocol: ${upload.protocol}`);
+  }
+  if (requiresHttps(upload)) {
+    throw rejectedUploadUrl("Upload URL must use HTTPS unless it targets loopback");
+  }
+}
+function isConvexLocalSiteUrl(upload, backend2) {
+  return isLoopbackHostname(upload.hostname) && isLoopbackHostname(backend2.hostname) && isConvexLocalSitePort(upload.port, backend2.port);
+}
+function isConvexCloudSiteUrl(upload, backend2) {
+  if (backend2.protocol !== "https:" || backend2.port !== "")
+    return false;
+  if (!backend2.hostname.endsWith(CONVEX_CLOUD_SUFFIX))
+    return false;
+  const siteOrigin = `https://${backend2.hostname.slice(0, -CONVEX_CLOUD_SUFFIX.length)}${CONVEX_SITE_SUFFIX}`;
+  return upload.origin === siteOrigin;
+}
+function assertUploadUrlAllowed(uploadUrl, backendUrl) {
+  const { upload, backend: backend2 } = parseUploadUrl(uploadUrl, backendUrl);
+  assertUploadProtocol(upload);
+  if (upload.origin === backend2.origin || isConvexLocalSiteUrl(upload, backend2) || isConvexCloudSiteUrl(upload, backend2)) {
+    return;
+  }
+  throw rejectedUploadUrl(`Upload URL origin ${upload.origin} does not match the configured backend ${backend2.origin}`);
+}
+async function readUploadError(response) {
+  try {
+    const body = await response.json();
+    return {
+      code: typeof body.code === "string" ? body.code : DEFAULT_UPLOAD_ERROR_CODE,
+      message: typeof body.message === "string" ? body.message : `Upload failed with status ${response.status}`
+    };
+  } catch {
+    return {
+      code: DEFAULT_UPLOAD_ERROR_CODE,
+      message: `Upload failed with status ${response.status}`
+    };
+  }
+}
+var ATTACHMENT_ID_HEADER = "X-Chatroom-Attachment-Id", DEFAULT_UPLOAD_ERROR_CODE = "FILE_ATTACHMENT_UPLOAD_FAILED", REJECTED_UPLOAD_URL_CODE = "FILE_ATTACHMENT_UPLOAD_URL_REJECTED", CONVEX_CLOUD_SUFFIX = ".convex.cloud", CONVEX_SITE_SUFFIX = ".convex.site";
+var init_convex_file_attachment_uploader = __esm(() => {
+  init_api3();
+  init_deps3();
+  init_client2();
+});
+
 // src/commands/handoff/index.ts
 var exports_handoff = {};
 __export(exports_handoff, {
@@ -75789,106 +76204,222 @@ __export(exports_handoff, {
 });
 async function createDefaultDeps10() {
   const deps = await createConvexCommandDeps();
-  return { backend: deps.backend, gateway: createLocalHandoffGateway(), session: deps.session };
+  return {
+    backend: deps.backend,
+    gateway: createLocalHandoffGateway(),
+    session: deps.session,
+    attachmentUploader: createConvexFileAttachmentUploader(deps.backend)
+  };
 }
-function handleHandoffError(err2) {
-  return exports_Effect.sync(() => {
-    if (err2._tag === "NotAuthenticated") {
+function toHandoffFailure(cause) {
+  let errorData;
+  if (cause instanceof ConvexError) {
+    errorData = cause.data;
+  } else if (cause instanceof LocalDaemonServerError && cause.details) {
+    errorData = cause.details;
+  }
+  return { _tag: "HandoffFailed", cause, errorData };
+}
+function callHandoffGateway(gateway, request3) {
+  return exports_Effect.tryPromise({
+    try: () => gateway(request3),
+    catch: (cause) => cause instanceof Error ? cause : new Error(String(cause))
+  }).pipe(exports_Effect.mapError(toHandoffFailure));
+}
+function discardAfterFailedHandoff(uploader, sessionId, attachedFileIds) {
+  if (!uploader || !attachedFileIds || attachedFileIds.length === 0)
+    return exports_Effect.void;
+  return discardHandoffAttachments(uploader, sessionId, attachedFileIds);
+}
+function performHandoff(args2) {
+  return exports_Effect.gen(function* () {
+    const result3 = yield* callHandoffGateway(args2.gateway, args2.request);
+    if (!result3.success && result3.error) {
+      return yield* exports_Effect.fail({
+        _tag: "HandoffRejected",
+        error: result3.error
+      });
+    }
+    return result3;
+  }).pipe(exports_Effect.catch((error51) => exports_Effect.gen(function* () {
+    yield* discardAfterFailedHandoff(args2.uploader, args2.sessionId, args2.attachedFileIds);
+    return yield* exports_Effect.fail(error51);
+  })));
+}
+function uploadHandoffFiles(uploader, args2) {
+  return exports_Effect.gen(function* () {
+    if (args2.attachFiles.length === 0)
+      return;
+    if (!uploader) {
+      return yield* exports_Effect.fail({
+        _tag: "AttachmentUploadFailed",
+        filename: "",
+        code: "UPLOAD_UNAVAILABLE",
+        message: "File attachments are not available in this environment"
+      });
+    }
+    const files = yield* prepareHandoffAttachments(args2.attachFiles, args2.nextRole);
+    return yield* uploadHandoffAttachments(uploader, {
+      sessionId: args2.sessionId,
+      chatroomId: args2.chatroomId,
+      senderRole: args2.senderRole,
+      files
+    });
+  });
+}
+function handleSessionError(err2) {
+  switch (err2._tag) {
+    case "NotAuthenticated":
       formatAuthError(err2.convexUrl, err2.otherUrls);
-      process.exit(1);
-    } else if (err2._tag === "InvalidChatroomId") {
+      return true;
+    case "InvalidChatroomId":
       formatChatroomIdError(err2.id);
-      process.exit(1);
-    } else if (err2._tag === "HandoffFailed") {
-      console.error(`
-❌ ERROR: Handoff failed`);
-      if (err2.errorData) {
-        console.error(`
-${err2.errorData.message || "An unexpected error occurred"}`);
-        if (process.env.CHATROOM_DEBUG === "true") {
-          console.error(`
+      return true;
+    default:
+      return false;
+  }
+}
+function printDebugInfo(value2) {
+  if (process.env.CHATROOM_DEBUG !== "true")
+    return;
+  console.error(`
 \uD83D\uDD0D Debug Info:`);
-          console.error(JSON.stringify(err2.errorData, null, 2));
-        }
-        if (err2.errorData.code === "AUTH_FAILED") {
-          console.error(`
+  console.error(value2);
+}
+function printHandoffFailureHint(code2) {
+  if (code2 === "AUTH_FAILED") {
+    console.error(`
 \uD83D\uDCA1 Try authenticating again:`);
-          console.error(`   chatroom auth login`);
-        } else if (err2.errorData.code === "INVALID_ROLE") {
-          console.error(`
+    console.error(`   chatroom auth login`);
+  } else if (code2 === "INVALID_ROLE") {
+    console.error(`
 \uD83D\uDCA1 Check your team configuration and use a valid role`);
-        }
-      } else {
-        console.error(`
+  }
+}
+function printHandoffFailed(err2) {
+  console.error(`
+❌ ERROR: Handoff failed`);
+  if (err2.errorData) {
+    console.error(`
+${err2.errorData.message || "An unexpected error occurred"}`);
+    printDebugInfo(JSON.stringify(err2.errorData, null, 2));
+    printHandoffFailureHint(err2.errorData.code);
+  } else {
+    console.error(`
 ${err2.cause instanceof Error ? err2.cause.message : String(err2.cause)}`);
-        if (process.env.CHATROOM_DEBUG === "true") {
-          console.error(`
-\uD83D\uDD0D Debug Info:`);
-          console.error(err2.cause);
-        }
-      }
-      console.error(`
+    printDebugInfo(err2.cause);
+  }
+  console.error(`
 \uD83D\uDCDA Need help? Check the docs or run:`);
-      console.error(`   chatroom handoff --help`);
-      process.exit(1);
-    } else if (err2._tag === "HandoffRejected") {
-      console.error(`
-❌ ERROR: ${err2.error.message}`);
-      if (err2.error.code === "INVALID_TARGET_ROLE" && err2.error.suggestedTargets) {
-        console.error(`
+  console.error(`   chatroom handoff --help`);
+}
+function printSuggestedTargets(targets) {
+  console.error(`
 \uD83D\uDCCB Available handoff targets for this team:`);
-        for (const target of err2.error.suggestedTargets) {
-          console.error(`   • ${target}`);
-        }
-        console.error(`
+  for (const target of targets) {
+    console.error(`   • ${target}`);
+  }
+  console.error(`
 \uD83D\uDCA1 Check your team's handoff rules in the system prompt for valid paths.`);
-      } else if (err2.error.suggestedTarget) {
-        console.error(`
+}
+function printSuggestedTarget(target) {
+  console.error(`
 \uD83D\uDCA1 Try this instead:`);
-        console.error("```");
-        console.error(`   chatroom handoff --next-role=${err2.error.suggestedTarget} ...`);
-        console.error("```");
-      }
+  console.error("```");
+  console.error(`   chatroom handoff --next-role=${target} ...`);
+  console.error("```");
+}
+function printHandoffRejected(err2) {
+  console.error(`
+❌ ERROR: ${err2.error.message}`);
+  if (err2.error.code === "INVALID_TARGET_ROLE" && err2.error.suggestedTargets) {
+    printSuggestedTargets(err2.error.suggestedTargets);
+  } else if (err2.error.suggestedTarget) {
+    printSuggestedTarget(err2.error.suggestedTarget);
+  }
+}
+function printAttachmentTargetFailure(err2) {
+  if (err2._tag === "AttachmentsRequireUserTarget") {
+    console.error(`
+❌ ERROR: --attach-file can only be used with --next-role=user. Agent-to-agent handoffs cannot carry files.`);
+    return;
+  }
+  console.error(`
+❌ ERROR: Too many files. At most ${err2.max} files can be attached to one handoff (got ${err2.count}).`);
+}
+function printAttachmentUploadFailure(err2) {
+  if (err2._tag === "AttachmentInvalid") {
+    console.error(`
+❌ ERROR: Cannot attach "${err2.path}": ${err2.reason}`);
+    return;
+  }
+  console.error(`
+❌ ERROR: Failed to upload "${err2.filename}": ${err2.message}`);
+  console.error(`   Code: ${err2.code}`);
+}
+function printAttachmentFailure(err2) {
+  if (err2._tag === "AttachmentsRequireUserTarget" || err2._tag === "AttachmentLimitExceeded") {
+    printAttachmentTargetFailure(err2);
+    return;
+  }
+  printAttachmentUploadFailure(err2);
+}
+function handleHandoffError(err2) {
+  return exports_Effect.sync(() => {
+    if (handleSessionError(err2)) {
       process.exit(1);
+      return;
     }
+    switch (err2._tag) {
+      case "HandoffFailed":
+        printHandoffFailed(err2);
+        break;
+      case "HandoffRejected":
+        printHandoffRejected(err2);
+        break;
+      default:
+        printAttachmentFailure(err2);
+        break;
+    }
+    process.exit(1);
   });
 }
 async function handoff(chatroomId, options, deps) {
   const d = deps ?? await createDefaultDeps10();
   const layer = commandServicesLayerFromDeps(d);
-  await exports_Effect.runPromise(handoffEffect(chatroomId, options).pipe(exports_Effect.catch((err2) => handleHandoffError(err2)), exports_Effect.provide(layer)));
+  await exports_Effect.runPromise(handoffEffect(chatroomId, options, d.attachmentUploader).pipe(exports_Effect.catch((err2) => handleHandoffError(err2)), exports_Effect.provide(layer)));
 }
-var handoffEffect = (chatroomId, options) => exports_Effect.gen(function* () {
+var handoffEffect = (chatroomId, options, attachmentUploader) => exports_Effect.gen(function* () {
   const session2 = yield* SessionService;
   const gateway = yield* CliGatewayService;
-  const { role, message, nextRole } = options;
+  const { role, message, nextRole, attachFiles = [] } = options;
   const sessionId = yield* requireSessionForChatroomEffect({ chatroomId });
-  const result3 = yield* exports_Effect.tryPromise({
-    try: () => gateway.handoff({
+  const attachedFileIds = yield* uploadHandoffFiles(attachmentUploader, {
+    sessionId,
+    chatroomId,
+    senderRole: role,
+    nextRole,
+    attachFiles
+  });
+  const result3 = yield* performHandoff({
+    gateway: gateway.handoff,
+    request: {
       sessionId,
       chatroomId,
       senderRole: role,
       content: message,
-      targetRole: nextRole
-    }),
-    catch: (cause) => cause instanceof Error ? cause : new Error(String(cause))
-  }).pipe(exports_Effect.mapError((cause) => {
-    let errorData;
-    if (cause instanceof ConvexError) {
-      errorData = cause.data;
-    } else if (cause instanceof LocalDaemonServerError && cause.details) {
-      errorData = cause.details;
-    }
-    return { _tag: "HandoffFailed", cause, errorData };
-  }));
-  if (!result3.success && result3.error) {
-    return yield* exports_Effect.fail({
-      _tag: "HandoffRejected",
-      error: result3.error
-    });
-  }
+      targetRole: nextRole,
+      ...attachedFileIds ? { attachedFileIds } : {}
+    },
+    uploader: attachmentUploader,
+    sessionId,
+    attachedFileIds
+  });
   const convexUrl = yield* session2.getConvexUrl();
   yield* exports_Effect.sync(() => {
+    if (result3.attachmentsDiscarded) {
+      console.error("Warning: this handoff was already recorded for this message, so the attached files were not delivered. " + "Send the files in a new handoff to user after the current one is complete.");
+    }
     console.log(generateHandoffOutput({
       role,
       nextRole,
@@ -75902,9 +76433,11 @@ var init_handoff = __esm(() => {
   init_generator();
   init_values();
   init_dist();
+  init_attachments();
   init_local_daemon();
   init_local_handoff_gateway();
   init_create_convex_command_deps();
+  init_convex_file_attachment_uploader();
   init_services();
   init_error_formatting();
 });
@@ -84266,7 +84799,7 @@ var init_parse_skill_file = __esm(() => {
 });
 
 // src/infrastructure/external-skills/discover-external-skills.ts
-import { lstat as lstat2, readdir as readdir2, readFile as readFile13, realpath, stat as stat8 } from "node:fs/promises";
+import { lstat as lstat2, readdir as readdir2, readFile as readFile14, realpath, stat as stat9 } from "node:fs/promises";
 import os from "node:os";
 import { join as join22 } from "node:path";
 function errorCode(err2) {
@@ -84341,7 +84874,7 @@ async function scanEntry(entry, sourcePath, state) {
 }
 async function isSkillCandidate(sourcePath, issues) {
   try {
-    if (!(await stat8(sourcePath)).isDirectory())
+    if (!(await stat9(sourcePath)).isDirectory())
       return false;
   } catch (err2) {
     issues.push(issue2(sourcePath, "unreadable", errorCode(err2)));
@@ -84349,7 +84882,7 @@ async function isSkillCandidate(sourcePath, issues) {
   }
   const skillPath = join22(sourcePath, SKILL_FILE_NAME);
   try {
-    const skillStat = await stat8(skillPath);
+    const skillStat = await stat9(skillPath);
     if (!skillStat.isFile())
       return false;
     if (skillStat.size > MAX_SKILL_FILE_BYTES) {
@@ -84374,7 +84907,7 @@ async function isSymlink2(path2) {
 }
 async function readSkillFile(sourcePath, issues) {
   try {
-    return await readFile13(join22(sourcePath, SKILL_FILE_NAME), "utf8");
+    return await readFile14(join22(sourcePath, SKILL_FILE_NAME), "utf8");
   } catch (err2) {
     issues.push(issue2(sourcePath, "unreadable", errorCode(err2)));
     return;
@@ -86865,7 +87398,7 @@ var init_orphan_tracker = __esm(() => {
 });
 
 // src/daemon/entry/handlers/process/output-store.ts
-import { appendFile as appendFile2, mkdir as mkdir10, readFile as readFile14, rm as rm3 } from "node:fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir10, readFile as readFile15, rm as rm3 } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join as join25 } from "node:path";
 
@@ -86898,7 +87431,7 @@ class TempFileOutputStore {
   async getLastNLines(maxLines) {
     let source;
     try {
-      source = await readFile14(this.state.filePath, "utf-8");
+      source = await readFile15(this.state.filePath, "utf-8");
     } catch {
       source = this.state.inMemory;
     }
@@ -86915,7 +87448,7 @@ class TempFileOutputStore {
   }
   async getFullOutput() {
     try {
-      return await readFile14(this.state.filePath, "utf-8");
+      return await readFile15(this.state.filePath, "utf-8");
     } catch {
       return this.state.inMemory;
     }
@@ -88545,7 +89078,7 @@ var init_workspace_visibility_policy = __esm(() => {
 
 // src/infrastructure/services/workspace/workspace-ignore.ts
 import { promises as fsPromises } from "node:fs";
-import { readFile as readFile15 } from "node:fs/promises";
+import { readFile as readFile16 } from "node:fs/promises";
 import { homedir as homedir11 } from "node:os";
 import path2 from "node:path";
 function normalizeRelativePath(relativePath) {
@@ -88610,7 +89143,7 @@ async function loadGitExtraExcludeRuleSets(rootDir) {
 }
 async function readIgnoreFile(filePath) {
   try {
-    return await readFile15(filePath, "utf-8");
+    return await readFile16(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -89582,7 +90115,7 @@ var init_git_workspace_hierarchy = __esm(() => {
 });
 
 // ../../node_modules/.pnpm/readdirp@5.1.1/node_modules/readdirp/index.js
-import { lstat as lstat3, readdir as readdir3, realpath as realpath2, stat as stat9 } from "node:fs/promises";
+import { lstat as lstat3, readdir as readdir3, realpath as realpath2, stat as stat10 } from "node:fs/promises";
 import { join as pjoin, resolve as presolve, sep as psep } from "node:path";
 import { Readable } from "node:stream";
 function readdirp(root, options = {}) {
@@ -89679,7 +90212,7 @@ var init_readdirp = __esm(() => {
       const type = opts.type ?? defaultOptions.type;
       this._fileFilter = normalizeFilter(opts.fileFilter);
       this._directoryFilter = normalizeFilter(opts.directoryFilter);
-      const statMethod = opts.lstat ? lstat3 : stat9;
+      const statMethod = opts.lstat ? lstat3 : stat10;
       if (wantBigintFsStats) {
         this._stat = (path5) => statMethod(path5, { bigint: true });
       } else {
@@ -89767,9 +90300,9 @@ var init_readdirp = __esm(() => {
       return { files, depth, path: path5 };
     }
     _formatEntry(dirent, path5) {
-      const basename7 = this._isDirent ? dirent.name : dirent;
-      const fullPath = pjoin(path5, basename7);
-      const entry = { path: fullPath.slice(this._relStart), fullPath, basename: basename7 };
+      const basename8 = this._isDirent ? dirent.name : dirent;
+      const fullPath = pjoin(path5, basename8);
+      const entry = { path: fullPath.slice(this._relStart), fullPath, basename: basename8 };
       if (this._isDirent) {
         entry.dirent = dirent;
         return entry;
@@ -89834,7 +90367,7 @@ var init_readdirp = __esm(() => {
 
 // ../../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/handler.js
 import { watch as fs_watch, unwatchFile, watchFile } from "node:fs";
-import { realpath as fsrealpath, lstat as lstat4, open, stat as stat10 } from "node:fs/promises";
+import { realpath as fsrealpath, lstat as lstat4, open, stat as stat11 } from "node:fs/promises";
 import { type as osType } from "node:os";
 import * as sp from "node:path";
 function createFsWatchInstance(path5, options, listener, errHandler, emitRaw) {
@@ -89865,9 +90398,9 @@ class NodeFsHandler {
   _watchWithNodeFs(path5, listener) {
     const opts = this.fsw.options;
     const directory = sp.dirname(path5);
-    const basename8 = sp.basename(path5);
+    const basename9 = sp.basename(path5);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename8);
+    parent.add(basename9);
     const absolutePath = sp.resolve(path5);
     const options = {
       persistent: opts.persistent
@@ -89877,7 +90410,7 @@ class NodeFsHandler {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename8) ? opts.binaryInterval : opts.interval;
+      options.interval = enableBin && isBinaryPath(basename9) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path5, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -89896,17 +90429,17 @@ class NodeFsHandler {
       return;
     }
     const dirname19 = sp.dirname(file2);
-    const basename8 = sp.basename(file2);
+    const basename9 = sp.basename(file2);
     const parent = this.fsw._getWatchedDir(dirname19);
     let prevStats = stats;
-    if (parent.has(basename8))
+    if (parent.has(basename9))
       return;
     const listener = async (path5, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
         try {
-          const newStats2 = await stat10(file2);
+          const newStats2 = await stat11(file2);
           if (this.fsw.closed)
             return;
           const at = newStats2.atimeMs;
@@ -89924,9 +90457,9 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error51) {
-          this.fsw._remove(dirname19, basename8);
+          this.fsw._remove(dirname19, basename9);
         }
-      } else if (parent.has(basename8)) {
+      } else if (parent.has(basename9)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -90262,7 +90795,7 @@ var init_handler = __esm(() => {
     ERROR: "error"
   };
   EV = EVENTS;
-  statMethods = { lstat: lstat4, stat: stat10 };
+  statMethods = { lstat: lstat4, stat: stat11 };
   HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
   binaryExtensions = new Set([
     "3dm",
@@ -90534,7 +91067,7 @@ var init_handler = __esm(() => {
 // ../../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
 import { EventEmitter } from "node:events";
 import { stat as statcb, Stats } from "node:fs";
-import { readdir as readdir4, stat as stat11 } from "node:fs/promises";
+import { readdir as readdir4, stat as stat12 } from "node:fs/promises";
 import * as sp2 from "node:path";
 function arrify(item) {
   return Array.isArray(item) ? item : [item];
@@ -90988,7 +91521,7 @@ var init_chokidar = __esm(() => {
         const fullPath = opts.cwd ? sp2.join(opts.cwd, path5) : path5;
         let stats2;
         try {
-          stats2 = await stat11(fullPath);
+          stats2 = await stat12(fullPath);
         } catch (err2) {}
         if (!stats2 || this.closed)
           return;
@@ -91092,8 +91625,8 @@ var init_chokidar = __esm(() => {
       }
       return this._userIgnored(path5, stats);
     }
-    _isntIgnored(path5, stat12) {
-      return !this._isIgnored(path5, stat12);
+    _isntIgnored(path5, stat13) {
+      return !this._isIgnored(path5, stat13);
     }
     _getWatchHelpers(path5) {
       return new WatchHelper(path5, this.options.followSymlinks, this);
@@ -93205,8 +93738,8 @@ function parseMakefileTargets(content) {
 var MAX_NAME_LENGTH2 = 256;
 
 // src/infrastructure/services/workspace/workspace-resolver.ts
-import { readFile as readFile17, readdir as readdir5, stat as stat12 } from "node:fs/promises";
-import { join as join30, basename as basename9, resolve as resolve11 } from "node:path";
+import { readFile as readFile18, readdir as readdir5, stat as stat13 } from "node:fs/promises";
+import { join as join30, basename as basename10, resolve as resolve11 } from "node:path";
 async function resolveGlobPatternStar(rootDir, cleaned) {
   const parentDir2 = join30(rootDir, cleaned.slice(0, -2));
   try {
@@ -93230,7 +93763,7 @@ async function resolveLiteralPath(rootDir, cleaned) {
   try {
     if (!resolve11(dir).startsWith(resolve11(rootDir)))
       return [];
-    const s = await stat12(dir);
+    const s = await stat13(dir);
     if (s.isDirectory())
       return [dir];
   } catch {}
@@ -93246,10 +93779,10 @@ async function resolveGlobPattern(rootDir, pattern) {
 }
 async function readPackageJson(dir) {
   try {
-    const content = await readFile17(join30(dir, "package.json"), "utf-8");
+    const content = await readFile18(join30(dir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     return {
-      name: pkg.name || basename9(dir),
+      name: pkg.name || basename10(dir),
       scripts: pkg.scripts && typeof pkg.scripts === "object" ? pkg.scripts : {}
     };
   } catch {
@@ -93258,7 +93791,7 @@ async function readPackageJson(dir) {
 }
 async function readPnpmWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile17(join30(rootDir, "pnpm-workspace.yaml"), "utf-8");
+    const content = await readFile18(join30(rootDir, "pnpm-workspace.yaml"), "utf-8");
     const patterns = [];
     let inPackages = false;
     for (const line of content.split(`
@@ -93285,7 +93818,7 @@ async function readPnpmWorkspacePatterns(rootDir) {
 }
 async function readPackageJsonWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile17(join30(rootDir, "package.json"), "utf-8");
+    const content = await readFile18(join30(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.workspaces)
       return [];
@@ -93333,8 +93866,8 @@ async function resolveSubWorkspaces(rootDir, pm) {
 var init_workspace_resolver = () => {};
 
 // src/infrastructure/services/workspace/command-discovery.ts
-import { access as access2, readFile as readFile18 } from "node:fs/promises";
-import { join as join31, relative as relative3, basename as basename10 } from "node:path";
+import { access as access2, readFile as readFile19 } from "node:fs/promises";
+import { join as join31, relative as relative3, basename as basename11 } from "node:path";
 async function detectPackageManager(workingDir) {
   for (const { file: file2, manager } of LOCKFILE_MAP) {
     try {
@@ -93382,7 +93915,7 @@ function isValidScriptEntry(name, script) {
 }
 async function readJsonFile(filePath, label) {
   try {
-    const content = await readFile18(filePath, "utf-8");
+    const content = await readFile19(filePath, "utf-8");
     return parseJsonc2(content);
   } catch (error51) {
     if (error51.code !== "ENOENT") {
@@ -93406,7 +93939,7 @@ function collectRootScriptCommands(scripts, pm, scriptPrefix, rootSw) {
   return commands;
 }
 async function readRootPackageJson(workingDir, pm, scriptPrefix) {
-  let rootPackageName = basename10(workingDir);
+  let rootPackageName = basename11(workingDir);
   const pkg = await readJsonFile(join31(workingDir, "package.json"), "root package.json");
   if (!pkg)
     return { commands: [], rootPackageName };
@@ -93439,7 +93972,7 @@ async function readDenoJson(workingDir) {
     const deno = await readJsonFile(join31(workingDir, fileName), fileName);
     if (!deno?.tasks || typeof deno.tasks !== "object")
       continue;
-    const pkgName = deno.name ?? basename10(workingDir);
+    const pkgName = deno.name ?? basename11(workingDir);
     const subWorkspace = { type: "deno", path: ".", name: pkgName };
     for (const [taskName, taskCommand] of Object.entries(deno.tasks)) {
       if (!isValidScriptEntry(taskName, taskCommand))
@@ -93459,14 +93992,14 @@ async function readMakefile(workingDir) {
   const commands = [];
   for (const fileName of ["Makefile", "makefile"]) {
     try {
-      const content = await readFile18(join31(workingDir, fileName), "utf-8");
+      const content = await readFile19(join31(workingDir, fileName), "utf-8");
       const targets = parseMakefileTargets(content);
       if (targets.length === 0)
         continue;
       const subWorkspace = {
         type: "make",
         path: ".",
-        name: basename10(workingDir)
+        name: basename11(workingDir)
       };
       for (const target of targets) {
         commands.push({
@@ -93597,8 +94130,8 @@ function createWorkspaceGitProbe(args2) {
 }
 async function statFingerprint(absPath) {
   try {
-    const stat13 = await fs7.stat(absPath);
-    return `${stat13.mtimeMs}:${stat13.size}`;
+    const stat14 = await fs7.stat(absPath);
+    return `${stat14.mtimeMs}:${stat14.size}`;
   } catch {
     return "missing";
   }
@@ -94624,12 +95157,12 @@ async function readCommandsUnits(workingDir) {
   return [{ kind: "commands", commands: commands.map(toCommandEntry) }];
 }
 async function readWorktreeUnits(workingDir) {
-  const [dirty, stat13] = await Promise.all([isDirty(workingDir), getDiffStat(workingDir)]);
+  const [dirty, stat14] = await Promise.all([isDirty(workingDir), getDiffStat(workingDir)]);
   return [
     {
       kind: "worktree",
       isDirty: dirty,
-      diffStat: stat13.status === "available" ? { ...stat13.diffStat } : { filesChanged: 0, insertions: 0, deletions: 0 }
+      diffStat: stat14.status === "available" ? { ...stat14.diffStat } : { filesChanged: 0, insertions: 0, deletions: 0 }
     }
   ];
 }
@@ -95006,7 +95539,7 @@ var init_workspace_service2 = __esm(() => {
 });
 
 // src/daemon/entry/init-daemon.ts
-import { stat as stat13 } from "node:fs/promises";
+import { stat as stat14 } from "node:fs/promises";
 async function discoverModelsForHarness(harness, service4) {
   const installed2 = await service4.isInstalled();
   if (!installed2) {
@@ -95041,7 +95574,7 @@ function createDefaultDeps22() {
       kill: (pid, signal) => process.kill(pid, signal)
     },
     fs: {
-      stat: stat13
+      stat: stat14
     },
     machine: {
       clearAgentPid,
@@ -98881,7 +99414,7 @@ var init_git_clone = __esm(() => {
 
 // src/infrastructure/local-actions/git-clone.ts
 import { spawn as spawn5 } from "node:child_process";
-import { readdir as readdir6, stat as stat14 } from "node:fs/promises";
+import { readdir as readdir6, stat as stat15 } from "node:fs/promises";
 function parseGitCloneProgressLine(line) {
   const match5 = PROGRESS_LINE_PATTERN.exec(line.trim());
   if (!match5?.[1] || !match5[2])
@@ -98895,7 +99428,7 @@ function classifyGitCloneFailure(stderrTail, spawnErrorCode) {
 }
 async function statOrNull(path8) {
   try {
-    return await stat14(path8);
+    return await stat15(path8);
   } catch (error51) {
     if (error51.code === "ENOENT")
       return null;
@@ -99579,7 +100112,7 @@ function gunzipBase64Payload(base643, maxBytes) {
 var init_workspace_path_security = () => {};
 
 // src/daemon/entry/files/file-content-fulfillment.ts
-import { readFile as readFile19 } from "node:fs/promises";
+import { readFile as readFile20 } from "node:fs/promises";
 import { gzipSync as gzipSync3 } from "node:zlib";
 function getErrorCause(error51) {
   if (typeof error51 === "object" && error51 !== null && "cause" in error51 && error51.cause !== undefined) {
@@ -99654,7 +100187,7 @@ var init_file_content_fulfillment = __esm(() => {
         continue;
       }
       let fileNotFound = false;
-      const buffer = yield* exports_Effect.catch(exports_Effect.tryPromise(() => readFile19(absolutePath)), (error51) => {
+      const buffer = yield* exports_Effect.catch(exports_Effect.tryPromise(() => readFile20(absolutePath)), (error51) => {
         if (isENOENT(error51)) {
           fileNotFound = true;
           return exports_Effect.succeed(Buffer.alloc(0));
@@ -99899,10 +100432,10 @@ function parseAttachmentFileName(remainder) {
   if (underscore <= 0)
     return false;
   const uuid3 = remainder.slice(0, underscore);
-  const basename11 = remainder.slice(underscore + 1);
-  if (!UUID_V4_RE.test(uuid3) || !basename11)
+  const basename12 = remainder.slice(underscore + 1);
+  if (!UUID_V4_RE.test(uuid3) || !basename12)
     return false;
-  return sanitizeChatAttachmentFileName(basename11) === basename11;
+  return sanitizeChatAttachmentFileName(basename12) === basename12;
 }
 function getInvalidChatAttachmentUploadPathReason(relativePath) {
   if (relativePath.includes("\\"))
@@ -99931,14 +100464,14 @@ function normalizeSegments(relativePath) {
 function hasBlockedSegment(lowerSegments) {
   return lowerSegments.some((segment) => BLOCKED_SEGMENT_NAMES.has(segment));
 }
-function hasBlockedBasename(basename11) {
-  return /^\.env(?:\.|$)/.test(basename11) || /\.(?:pem|key)$/.test(basename11) || basename11 === "id_rsa" || basename11 === "credentials.json";
+function hasBlockedBasename(basename12) {
+  return /^\.env(?:\.|$)/.test(basename12) || /\.(?:pem|key)$/.test(basename12) || basename12 === "id_rsa" || basename12 === "credentials.json";
 }
 function isBlockedUploadTargetPath(relativePath) {
   if (!relativePath)
     return false;
-  const { lowerSegments, basename: basename11 } = normalizeSegments(relativePath);
-  return hasBlockedSegment(lowerSegments) || hasBlockedBasename(basename11);
+  const { lowerSegments, basename: basename12 } = normalizeSegments(relativePath);
+  return hasBlockedSegment(lowerSegments) || hasBlockedBasename(basename12);
 }
 function getBlockedUploadTargetReason(relativePath) {
   if (!isBlockedUploadTargetPath(relativePath))
@@ -101830,7 +102363,7 @@ function createDaemonDeps(opts = {}) {
     })
   };
 }
-var init_deps3 = __esm(() => {
+var init_deps4 = __esm(() => {
   init_publisher_registry();
 });
 
@@ -119329,7 +119862,7 @@ var init_start_daemon = __esm(() => {
   init_daemon_layers();
   init_daemon_runtime();
   init_default_router_deps();
-  init_deps3();
+  init_deps4();
   init_execute_chatroom_stop_command();
   init_init_daemon();
   init_persistence_path();
@@ -120170,7 +120703,7 @@ async function runGenerate3dPreview(zip, options, command) {
   }
 }
 function registerGenerate3dCommand(program2) {
-  const generate3d2 = program2.command("generate-3d").description("Generate one 3D mesh (GLB) with a fal model, plus its JSON manifest and a zip/preview package").option("--model <id>", "fal endpoint id (default fal-ai/trellis-2); any id is accepted").option("--out <path>", "Output GLB path (required; manifest is written to <path>.json)").option("--platform <name>", "Generation platform: fal", parsePlatform, DEFAULT_GENERATE_3D_PLATFORM).option("--prompt <text>", "text prompt; with the default model, a reference image is generated first").option("--input-image <path-or-url>", "reference image (local file or URL); the image-to-3D input").option("--force", "replace existing output, reference, package, preview, rig, and clip files").option("--target-height <meters>", "Scale the model so its height is this many metres (positive, finite)", parseTargetHeight).option("--origin <origin>", "Where the origin goes: feet (bottom centre), center, or as-is (default)", parseOrigin, "as-is").option("--rig", "rig with Meshy 7.1 (requires --model meshy/v7.1/...); needs --confirm-cost on a real run").option("--animation-action-id <id>", "Meshy preset animation id (0-696), repeatable; requires --rig", collectRepeatable, []).option("--package-dir <dir>", "Directory for the package zip and preview (default: the directory of --out)").option("--input <json|@file>", "extra fal request fields as a JSON object, merged over the model defaults; reserved: prompt, image_url; @file reads JSON from a file").option("--confirm-cost", "confirm the priced plan for a real run that rigs or animates (Meshy 7.1 only), after the user confirms the priced dry run; not needed for --dry-run").option("--dry-run", "Validate and print the request and the static list-price estimate. No upload or fal generation call is made; FAL_API_KEY is not required").addHelpText("after", HELP_AFTER).action(runGenerate3d);
+  const generate3d2 = program2.command("generate-3d").description("Generate one 3D mesh (GLB) with a fal model, plus its JSON manifest and a zip/preview package").option("--model <id>", "fal endpoint id (default fal-ai/trellis-2); any id is accepted").option("--out <path>", "Output GLB path (required; manifest is written to <path>.json)").option("--platform <name>", "Generation platform: fal", parsePlatform, DEFAULT_GENERATE_3D_PLATFORM).option("--prompt <text>", "text prompt; with the default model, a reference image is generated first").option("--input-image <path-or-url>", "reference image (local file or URL); the image-to-3D input").option("--force", "replace existing output, reference, package, preview, rig, and clip files").option("--target-height <meters>", "Scale the model so its height is this many metres (positive, finite)", parseTargetHeight).option("--origin <origin>", "Where the origin goes: feet (bottom centre), center, or as-is (default)", parseOrigin, "as-is").option("--rig", "rig with Meshy 7.1 (requires --model meshy/v7.1/...); needs --confirm-cost on a real run").option("--animation-action-id <id>", "Meshy preset animation id (0-696), repeatable; requires --rig", collectRepeatable, []).option("--package-dir <dir>", "Directory for the package zip and preview (default: the directory of --out)").option("--input <json|@file>", "extra fal request fields as a JSON object, merged over the model defaults; reserved: prompt, image_url; @file reads JSON from a file").option("--confirm-cost", "confirm the priced plan for a real run that rigs or animates (Meshy 7.1 only), after the user confirms the priced dry run; not needed for --dry-run").option("--dry-run", "Validate and print the request and the static list-price estimate. No upload or fal generation call is made; FAL_API_KEY is not required. Refuses an existing output like a real run; add --force to print the plan anyway (a dry run writes nothing)").addHelpText("after", HELP_AFTER).action(runGenerate3d);
   generate3d2.command("preview <zip>").description("Rebuild <base>.html from an existing package zip, offline").option("--force", "replace an existing <base>.html").action(runGenerate3dPreview);
 }
 
@@ -120237,7 +120770,8 @@ async function runGenerateImage(options) {
       seed: options.seed,
       input,
       inputImage: options.inputImage,
-      force: options.force
+      force: options.force,
+      dryRun: options.dryRun === true
     };
     if (options.dryRun === true) {
       const { formatGenerateImagePlan: formatGenerateImagePlan2, planGenerateImage: planGenerateImage2 } = await Promise.resolve().then(() => (init_image(), exports_image));
@@ -120255,7 +120789,7 @@ async function runGenerateImage(options) {
   }
 }
 function registerGenerateImageCommand(program2) {
-  program2.command("generate-image").description("Generate one image with a fal model and write a JSON manifest next to it").requiredOption("--prompt <text>", "Text prompt describing the image").requiredOption("--out <path>", "Output image path (manifest is written to <path>.json)").option("--platform <name>", "Generation platform: fal", parsePlatform2, DEFAULT_GENERATE_IMAGE_PLATFORM).requiredOption("--model <id>", `fal model id (required), for example ${FLUX_2_FLASH_MODEL}, or ${FLUX_2_FLASH_EDIT_MODEL} with --input-image`).option("--aspect-ratio <ratio>", "Aspect ratio for models that take one, e.g. 1:1, 16:9 (omitted = model default). Rejected for models the CLI knows do not support it").option("--output-format <format>", "Output format: png or webp (omitted = model default)", parseOutputFormat).option("--seed <n>", "Seed for the random number generator", parseSeed).option("--input <json|@file>", "Model-specific JSON input object merged into the fal request; @file reads JSON from a file").option("--input-image <path-or-url>", `Image to edit: a local .png, .jpg, .jpeg, .webp, or .gif (uploaded to fal) or an http(s) URL. Requires an edit model such as ${FLUX_2_FLASH_EDIT_MODEL}`).option("--force", "Overwrite existing output and manifest files").option("--dry-run", "Validate and print the request, the model constraints the CLI knows, and the estimated fal cost. No upload or fal generation call is made; one read-only pricing request may be made when FAL_API_KEY is set (the key is not required)").addHelpText("after", HELP_AFTER2).action(runGenerateImage);
+  program2.command("generate-image").description("Generate one image with a fal model and write a JSON manifest next to it").requiredOption("--prompt <text>", "Text prompt describing the image").requiredOption("--out <path>", "Output image path (manifest is written to <path>.json)").option("--platform <name>", "Generation platform: fal", parsePlatform2, DEFAULT_GENERATE_IMAGE_PLATFORM).requiredOption("--model <id>", `fal model id (required), for example ${FLUX_2_FLASH_MODEL}, or ${FLUX_2_FLASH_EDIT_MODEL} with --input-image`).option("--aspect-ratio <ratio>", "Aspect ratio for models that take one, e.g. 1:1, 16:9 (omitted = model default). Rejected for models the CLI knows do not support it").option("--output-format <format>", "Output format: png or webp (omitted = model default)", parseOutputFormat).option("--seed <n>", "Seed for the random number generator", parseSeed).option("--input <json|@file>", "Model-specific JSON input object merged into the fal request; @file reads JSON from a file").option("--input-image <path-or-url>", `Image to edit: a local .png, .jpg, .jpeg, .webp, or .gif (uploaded to fal) or an http(s) URL. Requires an edit model such as ${FLUX_2_FLASH_EDIT_MODEL}`).option("--force", "Overwrite existing output and manifest files").option("--dry-run", "Validate and print the request, the model constraints the CLI knows, and the estimated fal cost. No upload or fal generation call is made; one read-only pricing request may be made when FAL_API_KEY is set (the key is not required). Refuses an existing output like a real run; add --force to print the plan anyway (a dry run writes nothing)").addHelpText("after", HELP_AFTER2).action(runGenerateImage);
 }
 
 // src/commands/register-chatroom-role-command.ts
@@ -120898,7 +121432,7 @@ function buildManifest3(asset, deps, tolerance, minAreaPercent, isolatedAt) {
     licensing: "unverified"
   };
 }
-async function preflight(outputs, tiles, force, deps) {
+async function preflight(outputs, tiles, force, dryRun, deps) {
   const sourcePaths = new Set;
   const sourceIdentities = [];
   for (const tile of tiles) {
@@ -120909,7 +121443,7 @@ async function preflight(outputs, tiles, force, deps) {
   }
   const conflicts = await findOutputConflicts(deps, outputs, sourcePaths, sourceIdentities, force);
   if (conflicts.length > 0)
-    throw new RemoveBackgroundError(formatConflicts(conflicts));
+    throw new RemoveBackgroundError(formatConflicts(conflicts, dryRun));
 }
 function encodeAsset(image, keyed, options, deps) {
   if (!options.trim) {
@@ -121031,7 +121565,7 @@ async function removeImageBackground(opts, deps) {
   }
   const tiles = inspected.map((tile) => decodeInput(tile, deps));
   const prepared = await prepareAssets(assignNames(mode, opts, tiles), mode, options, deps);
-  await preflight(prepared.flatMap((asset) => [asset.path, asset.manifestPath]), tiles, opts.force === true, deps);
+  await preflight(prepared.flatMap((asset) => [asset.path, asset.manifestPath]), tiles, opts.force === true, opts.dryRun === true, deps);
   const result = {
     dryRun: opts.dryRun === true,
     assets: toAssets(prepared),
@@ -121387,10 +121921,10 @@ function parseSourceManifest(raw, sheetSha, manifestPath) {
     warnings
   };
 }
-async function preflightOutputs(deps, paths, sourcePaths, sourceIdentities, force) {
+async function preflightOutputs(deps, paths, sourcePaths, sourceIdentities, force, dryRun) {
   const conflicts = await findOutputConflicts(deps, paths, sourcePaths, sourceIdentities, force);
   if (conflicts.length > 0) {
-    throw new SliceImageError(formatConflicts(conflicts));
+    throw new SliceImageError(formatConflicts(conflicts, dryRun));
   }
 }
 var EDGE_CONTENT_THRESHOLD = 25;
@@ -121612,7 +122146,7 @@ async function sliceImage(opts, deps) {
     await deps.fileIdentity(inPath),
     await deps.fileIdentity(sourceManifestPath)
   ];
-  await preflightOutputs(deps, allOutputPaths, new Set([inPath, sourceManifestPath]), sourceIdentities, force);
+  await preflightOutputs(deps, allOutputPaths, new Set([inPath, sourceManifestPath]), sourceIdentities, force, dryRun);
   const encoded = outputs.map((output) => {
     const cropped = cropTile(image, output.cell);
     let encodedBytes;
@@ -122023,7 +122557,7 @@ handoffCommandGroup.command("list-templates").description("Show the pair descrip
     legacyNextRole: parentOpts.nextRole
   });
 });
-handoffCommandGroup.option("--chatroom-id <id>", "Chatroom identifier").option("--role <role>", "Your role").option("--next-role <nextRole>", "Role to hand off to").action(async (options) => {
+handoffCommandGroup.option("--chatroom-id <id>", "Chatroom identifier").option("--role <role>", "Your role").option("--next-role <nextRole>", "Role to hand off to").option("--attach-file <path>", "File to attach (only with --next-role=user; repeatable, max 10, 10 MiB each)", collectMultiValueOption, []).action(async (options) => {
   const missing = [
     ["--chatroom-id", options.chatroomId],
     ["--role", options.role],
@@ -122056,7 +122590,8 @@ handoffCommandGroup.option("--chatroom-id <id>", "Chatroom identifier").option("
   await handoff2(chatroomId, {
     role,
     message,
-    nextRole
+    nextRole,
+    attachFiles: options.attachFile ?? []
   });
 });
 program2.command("notify-user").description("Send the user an update while you keep working (does not complete or transition your task)").requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").action(async (options) => {
@@ -122463,4 +122998,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=874F17B509E159FE64756E2164756E21
+//# debugId=954BAD59D75CD6A764756E2164756E21