create-dynamicagents 0.1.0 → 0.2.0

package/dist/cli.js

@@ -1,6 +1,3271 @@
 #!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
+  mod
+));
+
+// node_modules/sisteransi/src/index.js
+var require_src = __commonJS({
+  "node_modules/sisteransi/src/index.js"(exports, module) {
+    "use strict";
+    var ESC2 = "\x1B";
+    var CSI2 = `${ESC2}[`;
+    var beep = "\x07";
+    var cursor3 = {
+      to(x, y2) {
+        if (!y2) return `${CSI2}${x + 1}G`;
+        return `${CSI2}${y2 + 1};${x + 1}H`;
+      },
+      move(x, y2) {
+        let ret = "";
+        if (x < 0) ret += `${CSI2}${-x}D`;
+        else if (x > 0) ret += `${CSI2}${x}C`;
+        if (y2 < 0) ret += `${CSI2}${-y2}A`;
+        else if (y2 > 0) ret += `${CSI2}${y2}B`;
+        return ret;
+      },
+      up: (count = 1) => `${CSI2}${count}A`,
+      down: (count = 1) => `${CSI2}${count}B`,
+      forward: (count = 1) => `${CSI2}${count}C`,
+      backward: (count = 1) => `${CSI2}${count}D`,
+      nextLine: (count = 1) => `${CSI2}E`.repeat(count),
+      prevLine: (count = 1) => `${CSI2}F`.repeat(count),
+      left: `${CSI2}G`,
+      hide: `${CSI2}?25l`,
+      show: `${CSI2}?25h`,
+      save: `${ESC2}7`,
+      restore: `${ESC2}8`
+    };
+    var scroll = {
+      up: (count = 1) => `${CSI2}S`.repeat(count),
+      down: (count = 1) => `${CSI2}T`.repeat(count)
+    };
+    var erase3 = {
+      screen: `${CSI2}2J`,
+      up: (count = 1) => `${CSI2}1J`.repeat(count),
+      down: (count = 1) => `${CSI2}J`.repeat(count),
+      line: `${CSI2}2K`,
+      lineEnd: `${CSI2}K`,
+      lineStart: `${CSI2}1K`,
+      lines(count) {
+        let clear = "";
+        for (let i2 = 0; i2 < count; i2++)
+          clear += this.line + (i2 < count - 1 ? cursor3.up() : "");
+        if (count)
+          clear += cursor3.left;
+        return clear;
+      }
+    };
+    module.exports = { cursor: cursor3, scroll, erase: erase3, beep };
+  }
+});
+
+// src/cli.ts
 import { readFileSync } from "node:fs";
-import { welcome } from "./welcome.js";
-// Read at runtime rather than imported: `package.json` sits outside `rootDir`.
-const { version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
-console.log(welcome(version));
+import { readdir as readdir2, stat } from "node:fs/promises";
+import path2 from "node:path";
+
+// node_modules/@clack/core/dist/index.mjs
+import { styleText } from "node:util";
+import { stdout, stdin } from "node:process";
+import * as l from "node:readline";
+import l__default from "node:readline";
+
+// node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = /* @__PURE__ */ (() => {
+  const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  return (input) => {
+    let surrogatePairsNr = 0;
+    SURROGATE_PAIR_RE.lastIndex = 0;
+    while (SURROGATE_PAIR_RE.test(input)) {
+      surrogatePairsNr += 1;
+    }
+    return input.length - surrogatePairsNr;
+  };
+})();
+var isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x) => {
+  return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+// node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = new RegExp("[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation}|\\p{Emoji}\\uFE0F\\u20E3?))*", "yu");
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = new RegExp("\\p{M}+", "gu");
+var NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+  const PARSE_BLOCKS = [
+    [LATIN_RE, REGULAR_WIDTH],
+    [ANSI_RE, ANSI_WIDTH],
+    [CONTROL_RE, CONTROL_WIDTH],
+    [TAB_RE, TAB_WIDTH],
+    [EMOJI_RE, EMOJI_WIDTH],
+    [CJKT_WIDE_RE, WIDE_WIDTH]
+  ];
+  let indexPrev = 0;
+  let index = 0;
+  let length = input.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width2 = 0;
+  let widthExtra = 0;
+  outer: while (true) {
+    if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+      const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+      lengthExtra = 0;
+      for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+        const codePoint = char.codePointAt(0) || 0;
+        if (isFullWidth(codePoint)) {
+          widthExtra = FULL_WIDTH_WIDTH;
+        } else if (isWideNotCJKTNotEmoji(codePoint)) {
+          widthExtra = WIDE_WIDTH;
+        } else {
+          widthExtra = REGULAR_WIDTH;
+        }
+        if (width2 + widthExtra > truncationLimit) {
+          truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+        }
+        if (width2 + widthExtra > LIMIT) {
+          truncationEnabled = true;
+          break outer;
+        }
+        lengthExtra += char.length;
+        width2 += widthExtra;
+      }
+      unmatchedStart = unmatchedEnd = 0;
+    }
+    if (index >= length) {
+      break outer;
+    }
+    for (let i2 = 0, l2 = PARSE_BLOCKS.length; i2 < l2; i2++) {
+      const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i2];
+      BLOCK_RE.lastIndex = index;
+      if (BLOCK_RE.test(input)) {
+        lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+        widthExtra = lengthExtra * BLOCK_WIDTH;
+        if (width2 + widthExtra > truncationLimit) {
+          truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width2) / BLOCK_WIDTH));
+        }
+        if (width2 + widthExtra > LIMIT) {
+          truncationEnabled = true;
+          break outer;
+        }
+        width2 += widthExtra;
+        unmatchedStart = indexPrev;
+        unmatchedEnd = index;
+        index = indexPrev = BLOCK_RE.lastIndex;
+        continue outer;
+      }
+    }
+    index += 1;
+  }
+  return {
+    width: truncationEnabled ? truncationLimit : width2,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+};
+var dist_default = getStringTruncatedWidth;
+
+// node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+  return dist_default(input, NO_TRUNCATION2, options).width;
+};
+var dist_default2 = fastStringWidth;
+
+// node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "›";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return void 0;
+};
+var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible = lastRow === void 0 ? 0 : dist_default2(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default2(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible += characterLength;
+      if (visible === columns && !nextCharacter.done) {
+        rows.push("");
+        visible = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows.at(-1);
+  if (!visible && lastRow !== void 0 && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string) => {
+  const words2 = string.split(" ");
+  let last = words2.length;
+  while (last) {
+    if (dist_default2(words2[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words2.length) {
+    return string;
+  }
+  return words2.slice(0, last).join(" ") + words2.slice(last).join("");
+};
+var exec = (string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words2 = string.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index = 0; index < words2.length; index++) {
+    const word = words2[index];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default2(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    const wordLength = dist_default2(word);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default2(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join("\n");
+  let inSurrogate = false;
+  for (let i2 = 0; i2 < preString.length; i2++) {
+    const character = preString[i2];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i2 + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== void 0) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? void 0 : code;
+      } else if (groups?.uri !== void 0) {
+        escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+      }
+    }
+    if (preString[i2 + 1] === "\n") {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : void 0;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === "\n") {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+  }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join("\n");
+}
+
+// node_modules/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+import { ReadStream } from "node:tty";
+function findCursor(s, o, l2) {
+  if (!l2.some((r2) => !r2.disabled))
+    return s;
+  const t2 = s + o, n3 = Math.max(l2.length - 1, 0), e = t2 < 0 ? n3 : t2 > n3 ? 0 : t2;
+  return l2[e]?.disabled ? findCursor(e, o < 0 ? -1 : 1, l2) : e;
+}
+var a$1 = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var t = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var settings = {
+  actions: new Set(a$1),
+  aliases: /* @__PURE__ */ new Map([
+    // vim support
+    ["k", "up"],
+    ["j", "down"],
+    ["h", "left"],
+    ["l", "right"],
+    ["", "cancel"],
+    // opinionated defaults!
+    ["escape", "cancel"]
+  ]),
+  messages: {
+    cancel: "Canceled",
+    error: "Something went wrong"
+  },
+  withGuide: true,
+  accessible: void 0,
+  date: {
+    monthNames: [...t],
+    messages: {
+      required: "Please enter a valid date",
+      invalidMonth: "There are only 12 months in a year",
+      invalidDay: (n3, e) => `There are only ${n3} days in ${e}`,
+      afterMin: (n3) => `Date must be on or after ${n3.toISOString().slice(0, 10)}`,
+      beforeMax: (n3) => `Date must be on or before ${n3.toISOString().slice(0, 10)}`
+    }
+  }
+};
+function isAccessible(n3) {
+  if (n3 !== void 0) return n3;
+  if (settings.accessible !== void 0) return settings.accessible;
+  const e = process.env.ACCESSIBLE;
+  return e !== void 0 && e !== "" && e !== "0" && e !== "false";
+}
+function isActionKey(n3, e) {
+  if (typeof n3 == "string")
+    return settings.aliases.get(n3) === e;
+  for (const s of n3)
+    if (s !== void 0 && isActionKey(s, e))
+      return true;
+  return false;
+}
+function diffLines(i2, s) {
+  if (i2 === s) return;
+  const e = i2.split(`
+`), t2 = s.split(`
+`), r2 = Math.max(e.length, t2.length), f = [];
+  for (let n3 = 0; n3 < r2; n3++)
+    e[n3] !== t2[n3] && f.push(n3);
+  return {
+    lines: f,
+    numLinesBefore: e.length,
+    numLinesAfter: t2.length,
+    numLines: r2
+  };
+}
+var R = globalThis.process.platform.startsWith("win");
+var CANCEL_SYMBOL = /* @__PURE__ */ Symbol("clack:cancel");
+function isCancel(e) {
+  return e === CANCEL_SYMBOL;
+}
+function setRawMode(e, r2) {
+  const o = e;
+  o.isTTY && o.setRawMode(r2);
+}
+function block({
+  input: e = stdin,
+  output: r2 = stdout,
+  overwrite: o = true,
+  hideCursor: n3 = true
+} = {}) {
+  const s = l.createInterface({
+    input: e,
+    output: r2,
+    prompt: "",
+    tabSize: 1
+  });
+  l.emitKeypressEvents(e, s), e instanceof ReadStream && e.isTTY && e.setRawMode(true);
+  const t2 = (f, { name: a2, sequence: w }) => {
+    const c2 = String(f);
+    if (isActionKey([c2, a2, w], "cancel")) {
+      n3 && r2.write(import_sisteransi.cursor.show), process.exit(0);
+      return;
+    }
+    if (!o) return;
+    const i2 = a2 === "return" ? 0 : -1, m2 = a2 === "return" ? -1 : 0;
+    l.moveCursor(r2, i2, m2, () => {
+      l.clearLine(r2, 1, () => {
+        e.once("keypress", t2);
+      });
+    });
+  };
+  return n3 && r2.write(import_sisteransi.cursor.hide), e.once("keypress", t2), () => {
+    e.off("keypress", t2), n3 && r2.write(import_sisteransi.cursor.show), e instanceof ReadStream && e.isTTY && !R && e.setRawMode(false), s.terminal = false, s.close();
+  };
+}
+var getColumns = (e) => "columns" in e && typeof e.columns == "number" ? e.columns : 80;
+var getRows = (e) => "rows" in e && typeof e.rows == "number" ? e.rows : 20;
+function wrapTextWithPrefix(e, r2, o, n3 = o, s = o, t2) {
+  const f = getColumns(e ?? stdout);
+  return wrapAnsi(r2, f - o.length, {
+    hard: true,
+    trim: false
+  }).split(`
+`).map((c2, i2, m2) => {
+    const d = t2 ? t2(c2, i2) : c2;
+    return i2 === 0 ? `${n3}${d}` : i2 === m2.length - 1 ? `${s}${d}` : `${o}${d}`;
+  }).join(`
+`);
+}
+function runValidation(e, a2) {
+  if ("~standard" in e) {
+    const n3 = e["~standard"].validate(a2);
+    return n3 instanceof Promise ? n3.then((r2) => r2.issues?.at(0)?.message) : n3.issues?.at(0)?.message;
+  }
+  return e(a2);
+}
+var y = class {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map();
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  /**
+   * Whether accessible (static, screen-reader friendly) output is enabled for
+   * this prompt, resolved from the `accessible` option, the global setting,
+   * and the `ACCESSIBLE` env var.
+   */
+  get accessible() {
+    return isAccessible(this.opts.accessible);
+  }
+  constructor(t2, e = true) {
+    const { input: i2 = stdin, output: s = stdout, render: r2, signal: n3, ...o } = t2;
+    this.opts = o, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = r2.bind(this), this._track = e, this._abortSignal = n3, this.input = i2, this.output = s;
+  }
+  /**
+   * Unsubscribe all listeners
+   */
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  /**
+   * Set a subscriber with opts
+   * @param event - The event name
+   */
+  setSubscriber(t2, e) {
+    const i2 = this._subscribers.get(t2) ?? [];
+    i2.push(e), this._subscribers.set(t2, i2);
+  }
+  /**
+   * Subscribe to an event
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  on(t2, e) {
+    this.setSubscriber(t2, { cb: e });
+  }
+  /**
+   * Subscribe to an event once
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  once(t2, e) {
+    this.setSubscriber(t2, { cb: e, once: true });
+  }
+  /**
+   * Emit an event with data
+   * @param event - The event name
+   * @param data - The data to pass to the callback
+   */
+  emit(t2, ...e) {
+    const i2 = this._subscribers.get(t2) ?? [], s = [];
+    for (const r2 of i2)
+      r2.cb(...e), r2.once && s.push(() => i2.splice(i2.indexOf(r2), 1));
+    for (const r2 of s)
+      r2();
+  }
+  prompt() {
+    return new Promise((t2) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted)
+          return this.state = "cancel", this.close(), t2(CANCEL_SYMBOL);
+        this._abortSignal.addEventListener(
+          "abort",
+          () => {
+            this.state = "cancel", this.close();
+          },
+          { once: true }
+        );
+      }
+      this.rl = l__default.createInterface({
+        input: this.input,
+        tabSize: 2,
+        prompt: "",
+        escapeCodeTimeout: 50,
+        terminal: true
+      }), this.rl.prompt(), this.opts.initialUserInput !== void 0 && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), setRawMode(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(this.value);
+      }), this.once("cancel", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(CANCEL_SYMBOL);
+      });
+    });
+  }
+  _isActionKey(t2, e) {
+    return t2 === "	";
+  }
+  _shouldSubmit(t2, e) {
+    return true;
+  }
+  _setValue(t2) {
+    this.value = t2, this.emit("value", this.value);
+  }
+  _setUserInput(t2, e) {
+    this.userInput = t2 ?? "", this.emit("userInput", this.userInput), e && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
+  }
+  _clearUserInput() {
+    this.rl?.write(null, { ctrl: true, name: "u" }), this._setUserInput("");
+  }
+  async onKeypress(t2, e) {
+    if (this.state !== "validating") {
+      if (this._track && e.name !== "return" && (e.name && this._isActionKey(t2, e) && this.rl?.write(null, { ctrl: true, name: "h" }), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), e?.name && (!this._track && settings.aliases.has(e.name) && this.emit("cursor", settings.aliases.get(e.name)), settings.actions.has(e.name) && this.emit("cursor", e.name)), t2 && (t2.toLowerCase() === "y" || t2.toLowerCase() === "n") && this.emit("confirm", t2.toLowerCase() === "y"), this.emit("key", t2, e), e?.name === "return" && this._shouldSubmit(t2, e)) {
+        if (this.opts.validate) {
+          const i2 = runValidation(this.opts.validate, this.value);
+          let s;
+          i2 instanceof Promise ? (this.state = "validating", this.render(), s = await i2) : s = i2, s && (this.error = s instanceof Error ? s.message : s, this.state = "error", this.rl?.write(this.userInput));
+        }
+        this.state !== "error" && (this.state = "submit");
+      }
+      isActionKey([t2, e?.name, e?.sequence], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+    }
+  }
+  close() {
+    this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), setRawMode(this.input, false), this.rl?.close(), this.rl = void 0, this.emit(`${this.state}`, this.value), this.unsubscribe();
+  }
+  restoreCursor() {
+    const t2 = wrapAnsi(this._prevFrame, process.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(import_sisteransi.cursor.move(-999, t2 * -1));
+  }
+  render() {
+    const t2 = wrapAnsi(this._render(this) ?? "", process.stdout.columns, {
+      hard: true,
+      trim: false
+    });
+    if (t2 !== this._prevFrame) {
+      if (this.state === "initial")
+        this.output.write(import_sisteransi.cursor.hide);
+      else {
+        const e = diffLines(this._prevFrame, t2), i2 = getRows(this.output);
+        if (this.restoreCursor(), e) {
+          const s = Math.max(0, e.numLinesAfter - i2), r2 = Math.max(0, e.numLinesBefore - i2);
+          let n3 = e.lines.find((o) => o >= s);
+          if (n3 === void 0) {
+            this._prevFrame = t2;
+            return;
+          }
+          if (e.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, n3 - r2)), this.output.write(import_sisteransi.erase.lines(1));
+            const o = t2.split(`
+`);
+            this.output.write(o[n3]), this._prevFrame = t2, this.output.write(import_sisteransi.cursor.move(0, o.length - n3 - 1));
+            return;
+          } else if (e.lines.length > 1) {
+            if (s < r2)
+              n3 = s;
+            else {
+              const h2 = n3 - r2;
+              h2 > 0 && this.output.write(import_sisteransi.cursor.move(0, h2));
+            }
+            this.output.write(import_sisteransi.erase.down());
+            const f = t2.split(`
+`).slice(n3);
+            this.output.write(f.join(`
+`)), this._prevFrame = t2;
+            return;
+          }
+        }
+        this.output.write(import_sisteransi.erase.down());
+      }
+      this.output.write(t2), this.state === "initial" && (this.state = "active"), this._prevFrame = t2;
+    }
+  }
+};
+var r = class extends y {
+  get cursor() {
+    return this.value ? 0 : 1;
+  }
+  get _value() {
+    return this.cursor === 0;
+  }
+  constructor(t2) {
+    super(t2, false), this.value = !!t2.initialValue, this.on("userInput", () => {
+      this.value = this._value;
+    }), this.on("confirm", (i2) => {
+      this.output.write(import_sisteransi.cursor.move(0, -1)), this.value = i2, this.state = "submit", this.close();
+    }), this.on("cursor", () => {
+      this.value = !this.value;
+    });
+  }
+};
+var a = class extends y {
+  options;
+  cursor = 0;
+  get _value() {
+    return this.options[this.cursor]?.value;
+  }
+  get _enabledOptions() {
+    return this.options.filter((e) => e.disabled !== true);
+  }
+  toggleAll() {
+    const e = this._enabledOptions, i2 = this.value !== void 0 && this.value.length === e.length;
+    this.value = i2 ? [] : e.map((t2) => t2.value);
+  }
+  toggleInvert() {
+    const e = this.value;
+    if (!e)
+      return;
+    const i2 = this._enabledOptions.filter((t2) => !e.includes(t2.value));
+    this.value = i2.map((t2) => t2.value);
+  }
+  toggleValue() {
+    this.value === void 0 && (this.value = []);
+    const e = this.value.includes(this._value);
+    this.value = e ? this.value.filter((i2) => i2 !== this._value) : [...this.value, this._value];
+  }
+  constructor(e) {
+    super(e, false), this.options = e.options, this.value = [...e.initialValues ?? []];
+    const i2 = Math.max(
+      this.options.findIndex(({ value: t2 }) => t2 === e.cursorAt),
+      0
+    );
+    this.cursor = this.options[i2]?.disabled ? findCursor(i2, 1, this.options) : i2, this.on("key", (t2, l2) => {
+      l2.name === "a" && this.toggleAll(), l2.name === "i" && this.toggleInvert();
+    }), this.on("cursor", (t2) => {
+      switch (t2) {
+        case "left":
+        case "up":
+          this.cursor = findCursor(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = findCursor(this.cursor, 1, this.options);
+          break;
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+};
+var n$1 = class n extends y {
+  options;
+  cursor = 0;
+  get _selectedValue() {
+    return this.options[this.cursor];
+  }
+  changeValue() {
+    const e = this._selectedValue;
+    this.value = e === void 0 ? void 0 : e.value;
+  }
+  constructor(e) {
+    super(e, false), this.options = e.options;
+    const o = this.options.findIndex(({ value: s }) => s === e.initialValue), t2 = o === -1 ? 0 : o;
+    this.cursor = this.options[t2]?.disabled ? findCursor(t2, 1, this.options) : t2, this.changeValue(), this.on("cursor", (s) => {
+      switch (s) {
+        case "left":
+        case "up":
+          this.cursor = findCursor(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = findCursor(this.cursor, 1, this.options);
+          break;
+      }
+      this.changeValue();
+    });
+  }
+};
+var n2 = class extends y {
+  get userInputWithCursor() {
+    if (this.state === "submit")
+      return this.userInput;
+    const t2 = this.userInput;
+    if (this.cursor >= t2.length)
+      return `${this.userInput}█`;
+    const r2 = t2.slice(0, this.cursor), s = t2.slice(this.cursor, this.cursor + 1), e = t2.slice(this.cursor + 1);
+    return `${r2}${styleText("inverse", s)}${e}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  constructor(t2) {
+    super({
+      ...t2,
+      initialUserInput: t2.initialUserInput ?? t2.initialValue
+    }), this.on("userInput", (r2) => {
+      this._setValue(r2);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t2.defaultValue), this.value === void 0 && (this.value = "");
+    });
+  }
+};
+
+// node_modules/@clack/prompts/dist/index.mjs
+import { styleText as styleText2, stripVTControlCharacters } from "node:util";
+import process$1 from "node:process";
+var import_sisteransi2 = __toESM(require_src(), 1);
+function isUnicodeSupported() {
+  if (process$1.platform !== "win32") {
+    return process$1.env.TERM !== "linux";
+  }
+  return Boolean(process$1.env.CI) || Boolean(process$1.env.WT_SESSION) || Boolean(process$1.env.TERMINUS_SUBLIME) || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var unicode = isUnicodeSupported();
+var isCI = () => process.env.CI === "true";
+var unicodeOr = (o, e) => unicode ? o : e;
+var S_STEP_ACTIVE = unicodeOr("◆", "*");
+var S_STEP_CANCEL = unicodeOr("■", "x");
+var S_STEP_ERROR = unicodeOr("▲", "x");
+var S_STEP_SUBMIT = unicodeOr("◇", "o");
+var S_BAR_START = unicodeOr("┌", "T");
+var S_BAR = unicodeOr("│", "|");
+var S_BAR_END = unicodeOr("└", "—");
+var S_BAR_START_RIGHT = unicodeOr("┐", "T");
+var S_BAR_END_RIGHT = unicodeOr("┘", "—");
+var S_RADIO_ACTIVE = unicodeOr("●", ">");
+var S_RADIO_INACTIVE = unicodeOr("○", " ");
+var S_CHECKBOX_ACTIVE = unicodeOr("◻", "[•]");
+var S_CHECKBOX_SELECTED = unicodeOr("◼", "[+]");
+var S_CHECKBOX_INACTIVE = unicodeOr("◻", "[ ]");
+var S_PASSWORD_MASK = unicodeOr("▪", "•");
+var S_BAR_H = unicodeOr("─", "-");
+var S_CORNER_TOP_RIGHT = unicodeOr("╮", "+");
+var S_CONNECT_LEFT = unicodeOr("├", "+");
+var S_CORNER_BOTTOM_RIGHT = unicodeOr("╯", "+");
+var S_CORNER_BOTTOM_LEFT = unicodeOr("╰", "+");
+var S_CORNER_TOP_LEFT = unicodeOr("╭", "+");
+var S_INFO = unicodeOr("●", "•");
+var S_SUCCESS = unicodeOr("◆", "*");
+var S_WARN = unicodeOr("▲", "!");
+var S_ERROR = unicodeOr("■", "x");
+var symbol = (o) => {
+  switch (o) {
+    case "initial":
+    case "active":
+      return styleText2("cyan", S_STEP_ACTIVE);
+    case "cancel":
+      return styleText2("red", S_STEP_CANCEL);
+    case "error":
+      return styleText2("yellow", S_STEP_ERROR);
+    case "submit":
+      return styleText2("green", S_STEP_SUBMIT);
+    case "validating":
+      return styleText2("dim", S_STEP_ACTIVE);
+  }
+};
+var symbolBar = (o) => {
+  switch (o) {
+    case "initial":
+    case "active":
+      return styleText2("cyan", S_BAR);
+    case "cancel":
+      return styleText2("red", S_BAR);
+    case "error":
+      return styleText2("yellow", S_BAR);
+    case "submit":
+      return styleText2("green", S_BAR);
+  }
+};
+function formatInstructionFooter(o, e) {
+  const r2 = [`${e ? `${styleText2("cyan", S_BAR)}  ` : ""}${o.join(" • ")}`];
+  return e && r2.push(styleText2("cyan", S_BAR_END)), r2;
+}
+var I = (l2, e, w, p, b, C2 = false) => {
+  let r2 = e, O = 0;
+  if (C2)
+    for (let i2 = p - 1; i2 >= w; i2--) {
+      const m2 = l2[i2];
+      if (m2 && (r2 -= m2.length), O++, r2 <= b) break;
+    }
+  else
+    for (let i2 = w; i2 < p; i2++) {
+      const m2 = l2[i2];
+      if (m2 && (r2 -= m2.length), O++, r2 <= b) break;
+    }
+  return { lineCount: r2, removals: O };
+};
+var limitOptions = ({
+  cursor: l2,
+  options: e,
+  style: w,
+  output: p = process.stdout,
+  maxItems: b = Number.POSITIVE_INFINITY,
+  columnPadding: C2 = 0,
+  rowPadding: r2 = 4
+}) => {
+  const i2 = getColumns(p) - C2, m2 = getRows(p), M = styleText2("dim", "..."), v = Math.max(m2 - r2, 0), a2 = Math.max(Math.min(b, v), 5);
+  let f = 0;
+  l2 >= a2 - 3 && (f = Math.max(
+    Math.min(l2 - a2 + 3, e.length - a2),
+    0
+  ));
+  let d = a2 < e.length && f > 0, c2 = a2 < e.length && f + a2 < e.length;
+  const W2 = Math.min(
+    f + a2,
+    e.length
+  ), s = [];
+  let g = 0;
+  d && g++, c2 && g++;
+  const T = f + (d ? 1 : 0), y2 = W2 - (c2 ? 1 : 0);
+  for (let t2 = T; t2 < y2; t2++) {
+    const n3 = e[t2], o = n3 ? w(n3, t2 === l2) : "", h2 = wrapAnsi(o, i2, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    s.push(h2), g += h2.length;
+  }
+  if (g > v) {
+    let t2 = 0, n3 = 0, o = g;
+    const h2 = l2 - T;
+    let u3 = v;
+    const L = () => I(s, o, 0, h2, u3), E = () => I(
+      s,
+      o,
+      h2 + 1,
+      s.length,
+      u3,
+      true
+    );
+    d ? ({ lineCount: o, removals: t2 } = L(), o > u3 && (c2 || (u3 -= 1), { lineCount: o, removals: n3 } = E())) : (c2 || (u3 -= 1), { lineCount: o, removals: n3 } = E(), o > u3 && (u3 -= 1, { lineCount: o, removals: t2 } = L())), t2 > 0 && (d = true, s.splice(0, t2)), n3 > 0 && (c2 = true, s.splice(s.length - n3, n3));
+  }
+  const x = [];
+  d && x.push(M);
+  for (const t2 of s)
+    for (const n3 of t2)
+      x.push(n3);
+  return c2 && x.push(M), x;
+};
+var confirm = (e) => {
+  const a2 = e.active ?? "Yes", o = e.inactive ?? "No";
+  return new r({
+    active: a2,
+    inactive: o,
+    signal: e.signal,
+    input: e.input,
+    output: e.output,
+    initialValue: e.initialValue ?? true,
+    render() {
+      const i2 = e.withGuide ?? settings.withGuide, u3 = `${symbol(this.state)}  `, l2 = i2 ? `${styleText2("gray", S_BAR)}  ` : "", f = wrapTextWithPrefix(
+        e.output,
+        e.message,
+        l2,
+        u3
+      ), s = `${i2 ? `${styleText2("gray", S_BAR)}
+` : ""}${f}
+`, c2 = this.value ? a2 : o;
+      switch (this.state) {
+        case "submit": {
+          const r2 = i2 ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${s}${r2}${styleText2("dim", c2)}`;
+        }
+        case "cancel": {
+          const r2 = i2 ? `${styleText2("gray", S_BAR)}  ` : "";
+          return `${s}${r2}${styleText2(["strikethrough", "dim"], c2)}${i2 ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r2 = i2 ? `${styleText2("cyan", S_BAR)}  ` : "", g = i2 ? styleText2("cyan", S_BAR_END) : "";
+          return `${s}${r2}${this.value ? `${styleText2("green", S_RADIO_ACTIVE)} ${a2}` : `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", a2)}`}${e.vertical ? i2 ? `
+${styleText2("cyan", S_BAR)}  ` : `
+` : ` ${styleText2("dim", "/")} `}${this.value ? `${styleText2("dim", S_RADIO_INACTIVE)} ${styleText2("dim", o)}` : `${styleText2("green", S_RADIO_ACTIVE)} ${o}`}
+${g}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var MULTISELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "↑/↓")} to navigate`,
+  `${styleText2("dim", "Space:")} select`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var m = (i2, u3) => i2.split(`
+`).map((d) => u3(d)).join(`
+`);
+var multiselect = (i2) => {
+  const u3 = (t2, a2) => {
+    const r2 = t2.label ?? String(t2.value);
+    return a2 === "disabled" ? `${styleText2("gray", S_CHECKBOX_INACTIVE)} ${m(r2, (o) => styleText2(["strikethrough", "gray"], o))}${t2.hint ? ` ${styleText2("dim", `(${t2.hint ?? "disabled"})`)}` : ""}` : a2 === "active" ? `${styleText2("cyan", S_CHECKBOX_ACTIVE)} ${r2}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : a2 === "selected" ? `${styleText2("green", S_CHECKBOX_SELECTED)} ${m(r2, (o) => styleText2("dim", o))}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : a2 === "cancelled" ? `${m(r2, (o) => styleText2(["strikethrough", "dim"], o))}` : a2 === "active-selected" ? `${styleText2("green", S_CHECKBOX_SELECTED)} ${r2}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}` : a2 === "submitted" ? `${m(r2, (o) => styleText2("dim", o))}` : `${styleText2("dim", S_CHECKBOX_INACTIVE)} ${m(r2, (o) => styleText2("dim", o))}`;
+  }, d = i2.required ?? true, x = i2.showInstructions ?? true;
+  return new a({
+    options: i2.options,
+    signal: i2.signal,
+    input: i2.input,
+    output: i2.output,
+    initialValues: i2.initialValues,
+    required: d,
+    cursorAt: i2.cursorAt,
+    validate(t2) {
+      if (d && (t2 === void 0 || t2.length === 0))
+        return `Please select at least one option.
+${styleText2(
+          "reset",
+          styleText2(
+            "dim",
+            `Press ${styleText2(["gray", "bgWhite", "inverse"], " space ")} to select, ${styleText2(
+              "gray",
+              styleText2("bgWhite", styleText2("inverse", " enter "))
+            )} to submit`
+          )
+        )}`;
+    },
+    render() {
+      const t2 = i2.withGuide ?? settings.withGuide, a2 = wrapTextWithPrefix(
+        i2.output,
+        i2.message,
+        t2 ? `${symbolBar(this.state)}  ` : "",
+        `${symbol(this.state)}  `
+      ), r2 = `${t2 ? `${styleText2("gray", S_BAR)}
+` : ""}${a2}
+`, o = this.value ?? [], g = (n3, l2) => {
+        if (n3.disabled)
+          return u3(n3, "disabled");
+        const s = o.includes(n3.value);
+        return l2 && s ? u3(n3, "active-selected") : s ? u3(n3, "selected") : u3(n3, l2 ? "active" : "inactive");
+      };
+      switch (this.state) {
+        case "submit": {
+          const n3 = this.options.filter(({ value: s }) => o.includes(s)).map((s) => u3(s, "submitted")).join(styleText2("dim", ", ")) || styleText2("dim", "none"), l2 = wrapTextWithPrefix(
+            i2.output,
+            n3,
+            t2 ? `${styleText2("gray", S_BAR)}  ` : ""
+          );
+          return `${r2}${l2}`;
+        }
+        case "cancel": {
+          const n3 = this.options.filter(({ value: s }) => o.includes(s)).map((s) => u3(s, "cancelled")).join(styleText2("dim", ", "));
+          if (n3.trim() === "")
+            return `${r2}${styleText2("gray", S_BAR)}`;
+          const l2 = wrapTextWithPrefix(
+            i2.output,
+            n3,
+            t2 ? `${styleText2("gray", S_BAR)}  ` : ""
+          );
+          return `${r2}${l2}${t2 ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        case "error": {
+          const n3 = t2 ? `${styleText2("yellow", S_BAR)}  ` : "", l2 = this.error.split(`
+`).map(
+            ($, v) => v === 0 ? `${t2 ? `${styleText2("yellow", S_BAR_END)}  ` : ""}${styleText2("yellow", $)}` : `   ${$}`
+          ).join(`
+`), s = r2.split(`
+`).length, h2 = l2.split(`
+`).length + 1;
+          return `${r2}${n3}${limitOptions({
+            output: i2.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: i2.maxItems,
+            columnPadding: n3.length,
+            rowPadding: s + h2,
+            style: g
+          }).join(`
+${n3}`)}
+${l2}
+`;
+        }
+        default: {
+          const n3 = t2 ? `${styleText2("cyan", S_BAR)}  ` : "", l2 = r2.split(`
+`).length, s = x ? formatInstructionFooter(MULTISELECT_INSTRUCTIONS, t2) : t2 ? [styleText2("cyan", S_BAR_END)] : [], h2 = s.join(`
+`), $ = s.length + 1;
+          return `${r2}${n3}${limitOptions({
+            output: i2.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: i2.maxItems,
+            columnPadding: n3.length,
+            rowPadding: l2 + $,
+            style: g
+          }).join(`
+${n3}`)}
+${h2}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var log = {
+  message: (s = [], {
+    symbol: e = styleText2("gray", S_BAR),
+    secondarySymbol: r2 = styleText2("gray", S_BAR),
+    output: m2 = process.stdout,
+    spacing: l2 = 1,
+    withGuide: c2
+  } = {}) => {
+    const t2 = [], o = c2 ?? settings.withGuide, f = o ? r2 : "", O = o ? `${e}  ` : "", u3 = o ? `${r2}  ` : "";
+    for (let i2 = 0; i2 < l2; i2++)
+      t2.push(f);
+    const g = Array.isArray(s) ? s : s.split(`
+`);
+    if (g.length > 0) {
+      const [i2, ...y2] = g;
+      i2.length > 0 ? t2.push(`${O}${i2}`) : t2.push(o ? e : "");
+      for (const p of y2)
+        p.length > 0 ? t2.push(`${u3}${p}`) : t2.push(o ? r2 : "");
+    }
+    m2.write(`${t2.join(`
+`)}
+`);
+  },
+  info: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("blue", S_INFO) });
+  },
+  success: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("green", S_SUCCESS) });
+  },
+  step: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("green", S_STEP_SUBMIT) });
+  },
+  warn: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("yellow", S_WARN) });
+  },
+  /** alias for `log.warn()`. */
+  warning: (s, e) => {
+    log.warn(s, e);
+  },
+  error: (s, e) => {
+    log.message(s, { ...e, symbol: styleText2("red", S_ERROR) });
+  }
+};
+var cancel = (o = "", t2) => {
+  const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_END)}  ` : "";
+  i2.write(`${e}${styleText2("red", o)}
+
+`);
+};
+var intro = (o = "", t2) => {
+  const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR_START)}  ` : "";
+  i2.write(`${e}${o}
+`);
+};
+var outro = (o = "", t2) => {
+  const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText2("gray", S_BAR)}
+${styleText2("gray", S_BAR_END)}  ` : "";
+  i2.write(`${e}${o}
+
+`);
+};
+var W$1 = (o) => o;
+var C = (o, e, s) => {
+  const a2 = {
+    hard: true,
+    trim: false
+  }, i2 = wrapAnsi(o, e, a2).split(`
+`), c2 = i2.reduce((n3, t2) => Math.max(dist_default2(t2), n3), 0), u3 = i2.map(s).reduce((n3, t2) => Math.max(dist_default2(t2), n3), 0), g = e - (u3 - c2);
+  return wrapAnsi(o, g, a2);
+};
+var note = (o = "", e = "", s) => {
+  const a2 = s?.output ?? process$1.stdout, i2 = s?.withGuide ?? settings.withGuide, c2 = s?.format ?? W$1, g = ["", ...C(o, getColumns(a2) - 6, c2).split(`
+`).map(c2), ""], n3 = dist_default2(e), t2 = Math.max(
+    g.reduce((m2, F) => {
+      const O = dist_default2(F);
+      return O > m2 ? O : m2;
+    }, 0),
+    n3
+  ) + 2, h2 = g.map(
+    (m2) => `${styleText2("gray", S_BAR)}  ${m2}${" ".repeat(t2 - dist_default2(m2))}${styleText2("gray", S_BAR)}`
+  ).join(`
+`), T = i2 ? `${styleText2("gray", S_BAR)}
+` : "", l$1 = i2 ? S_CONNECT_LEFT : S_CORNER_BOTTOM_LEFT;
+  a2.write(
+    `${T}${styleText2("green", S_STEP_SUBMIT)}  ${styleText2("reset", e)} ${styleText2(
+      "gray",
+      S_BAR_H.repeat(Math.max(t2 - n3 - 1, 1)) + S_CORNER_TOP_RIGHT
+    )}
+${h2}
+${styleText2("gray", l$1 + S_BAR_H.repeat(t2 + 2) + S_CORNER_BOTTOM_RIGHT)}
+`
+  );
+};
+var W = (l2) => styleText2("magenta", l2);
+var spinner = ({
+  indicator: l2 = "dots",
+  onCancel: h2,
+  output: n3 = process.stdout,
+  cancelMessage: G,
+  errorMessage: O,
+  frames: E = unicode ? ["◒", "◐", "◓", "◑"] : ["•", "o", "O", "0"],
+  delay: F = unicode ? 80 : 120,
+  signal: m2,
+  ...I2
+} = {}) => {
+  const u3 = isCI();
+  let M, T, d = false, S = false, s = "", p, w = performance.now();
+  const x = getColumns(n3), k = I2?.styleFrame ?? W, g = (e) => {
+    const r2 = e > 1 ? O ?? settings.messages.error : G ?? settings.messages.cancel;
+    S = e === 1, d && (a2(r2, e), S && typeof h2 == "function" && h2());
+  }, f = () => g(2), i2 = () => g(1), A = () => {
+    process.on("uncaughtExceptionMonitor", f), process.on("unhandledRejection", f), process.on("SIGINT", i2), process.on("SIGTERM", i2), process.on("exit", g), m2 && m2.addEventListener("abort", i2);
+  }, H = () => {
+    process.removeListener("uncaughtExceptionMonitor", f), process.removeListener("unhandledRejection", f), process.removeListener("SIGINT", i2), process.removeListener("SIGTERM", i2), process.removeListener("exit", g), m2 && m2.removeEventListener("abort", i2);
+  }, y2 = () => {
+    if (p === void 0) return;
+    u3 && n3.write(`
+`);
+    const r2 = wrapAnsi(p, x, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    r2.length > 1 && n3.write(import_sisteransi2.cursor.up(r2.length - 1)), n3.write(import_sisteransi2.cursor.to(0)), n3.write(import_sisteransi2.erase.down());
+  }, C2 = (e) => e.replace(/\.+$/, ""), _ = (e) => {
+    const r2 = (performance.now() - e) / 1e3, t2 = Math.floor(r2 / 60), o = Math.floor(r2 % 60);
+    return t2 > 0 ? `[${t2}m ${o}s]` : `[${o}s]`;
+  }, N = I2.withGuide ?? settings.withGuide, P = (e = "") => {
+    d = true, M = block({ output: n3 }), s = C2(e), w = performance.now(), N && n3.write(`${styleText2("gray", S_BAR)}
+`);
+    let r2 = 0, t2 = 0;
+    A(), T = setInterval(() => {
+      if (u3 && s === p)
+        return;
+      y2(), p = s;
+      const o = k(E[r2]);
+      let v;
+      if (u3)
+        v = `${o}  ${s}...`;
+      else if (l2 === "timer")
+        v = `${o}  ${s} ${_(w)}`;
+      else {
+        const B = ".".repeat(Math.floor(t2)).slice(0, 3);
+        v = `${o}  ${s}${B}`;
+      }
+      const j = wrapAnsi(v, x, {
+        hard: true,
+        trim: false
+      });
+      n3.write(j), r2 = r2 + 1 < E.length ? r2 + 1 : 0, t2 = t2 < 4 ? t2 + 0.125 : 0;
+    }, F);
+  }, a2 = (e = "", r2 = 0, t2 = false) => {
+    if (!d) return;
+    d = false, clearInterval(T), y2();
+    const o = r2 === 0 ? styleText2("green", S_STEP_SUBMIT) : r2 === 1 ? styleText2("red", S_STEP_CANCEL) : styleText2("red", S_STEP_ERROR);
+    s = e ?? s, t2 || (l2 === "timer" ? n3.write(`${o}  ${s} ${_(w)}
+`) : n3.write(`${o}  ${s}
+`)), H(), M();
+  };
+  return {
+    start: P,
+    stop: (e = "") => a2(e, 0),
+    message: (e = "") => {
+      s = C2(e ?? s);
+    },
+    cancel: (e = "") => a2(e, 1),
+    error: (e = "") => a2(e, 2),
+    clear: () => a2("", 0, true),
+    get isCancelled() {
+      return S;
+    }
+  };
+};
+var u2 = {
+  light: unicodeOr("─", "-"),
+  heavy: unicodeOr("━", "="),
+  block: unicodeOr("█", "#")
+};
+var SELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "↑/↓")} to navigate`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var c = (t2, o) => t2.includes(`
+`) ? t2.split(`
+`).map((d) => o(d)).join(`
+`) : o(t2);
+var select = (t2) => {
+  const o = (n3, m2) => {
+    if (n3 === void 0)
+      return "";
+    const s = n3.label ?? String(n3.value);
+    switch (m2) {
+      case "disabled":
+        return `${styleText2("gray", S_RADIO_INACTIVE)} ${c(s, (i2) => styleText2("gray", i2))}${n3.hint ? ` ${styleText2("dim", `(${n3.hint ?? "disabled"})`)}` : ""}`;
+      case "selected":
+        return `${c(s, (i2) => styleText2("dim", i2))}`;
+      case "active":
+        return `${styleText2("green", S_RADIO_ACTIVE)} ${s}${n3.hint ? ` ${styleText2("dim", `(${n3.hint})`)}` : ""}`;
+      case "cancelled":
+        return `${c(s, (i2) => styleText2(["strikethrough", "dim"], i2))}`;
+      default:
+        return `${styleText2("dim", S_RADIO_INACTIVE)} ${c(s, (i2) => styleText2("dim", i2))}`;
+    }
+  }, d = t2.showInstructions ?? true;
+  return new n$1({
+    options: t2.options,
+    signal: t2.signal,
+    input: t2.input,
+    output: t2.output,
+    initialValue: t2.initialValue,
+    render() {
+      const n3 = t2.withGuide ?? settings.withGuide, m2 = `${symbol(this.state)}  `, s = `${symbolBar(this.state)}  `, i2 = wrapTextWithPrefix(
+        t2.output,
+        t2.message,
+        s,
+        m2
+      ), u3 = `${n3 ? `${styleText2("gray", S_BAR)}
+` : ""}${i2}
+`;
+      switch (this.state) {
+        case "submit": {
+          const r2 = n3 ? `${styleText2("gray", S_BAR)}  ` : "", a2 = wrapTextWithPrefix(
+            t2.output,
+            o(this.options[this.cursor], "selected"),
+            r2
+          );
+          return `${u3}${a2}`;
+        }
+        case "cancel": {
+          const r2 = n3 ? `${styleText2("gray", S_BAR)}  ` : "", a2 = wrapTextWithPrefix(
+            t2.output,
+            o(this.options[this.cursor], "cancelled"),
+            r2
+          );
+          return `${u3}${a2}${n3 ? `
+${styleText2("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r2 = n3 ? `${styleText2("cyan", S_BAR)}  ` : "", a2 = u3.split(`
+`).length, p = d ? formatInstructionFooter(SELECT_INSTRUCTIONS, n3) : n3 ? [styleText2("cyan", S_BAR_END)] : [], f = p.join(`
+`), b = p.length + 1;
+          return `${u3}${r2}${limitOptions({
+            output: t2.output,
+            cursor: this.cursor,
+            options: this.options,
+            maxItems: t2.maxItems,
+            columnPadding: r2.length,
+            rowPadding: a2 + b,
+            style: (g, x) => o(g, g.disabled ? "disabled" : x ? "active" : "inactive")
+          }).join(`
+${r2}`)}
+${f}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var i = `${styleText2("gray", S_BAR)}  `;
+var text = (t2) => new n2({
+  validate: t2.validate,
+  placeholder: t2.placeholder,
+  defaultValue: t2.defaultValue,
+  initialValue: t2.initialValue,
+  output: t2.output,
+  signal: t2.signal,
+  input: t2.input,
+  render() {
+    const r2 = t2?.withGuide ?? settings.withGuide, l2 = `${`${r2 ? `${styleText2("gray", S_BAR)}
+` : ""}${symbol(this.state)}  `}${t2.message}
+`, d = t2.placeholder && t2.placeholder.length > 0 ? (
+      // biome-ignore lint/style/noNonNullAssertion: guarded by placeholder.length > 0
+      styleText2("inverse", t2.placeholder[0]) + styleText2("dim", t2.placeholder.slice(1))
+    ) : styleText2(["inverse", "hidden"], "_"), o = this.userInput ? this.userInputWithCursor : d, s = this.value ?? "";
+    switch (this.state) {
+      case "validating": {
+        const n3 = r2 ? `${styleText2("cyan", S_BAR)}  ` : "", i2 = r2 ? styleText2("cyan", S_BAR_END) : "", c2 = styleText2("dim", o), $ = styleText2("dim", "Validating...");
+        return `${l2}${n3}${c2}
+${i2}  ${$}
+`;
+      }
+      case "error": {
+        const n3 = this.error ? `  ${styleText2("yellow", this.error)}` : "", i2 = r2 ? `${styleText2("yellow", S_BAR)}  ` : "", c2 = r2 ? styleText2("yellow", S_BAR_END) : "";
+        return `${l2.trim()}
+${i2}${o}
+${c2}${n3}
+`;
+      }
+      case "submit": {
+        const n3 = s ? `${r2 ? "  " : ""}${styleText2("dim", s)}` : "", i2 = r2 ? styleText2("gray", S_BAR) : "";
+        return `${l2}${i2}${n3}`;
+      }
+      case "cancel": {
+        const n3 = s ? `  ${styleText2(["strikethrough", "dim"], s)}` : "", i2 = r2 ? styleText2("gray", S_BAR) : "";
+        return `${l2}${i2}${n3}${s.trim() ? `
+${i2}` : ""}`;
+      }
+      default: {
+        const n3 = r2 ? `${styleText2("cyan", S_BAR)}  ` : "", i2 = r2 ? styleText2("cyan", S_BAR_END) : "";
+        return `${l2}${n3}${o}
+${i2}
+`;
+      }
+    }
+  }
+}).prompt();
+
+// src/agent/offer/blueprints.ts
+var BLUEPRINTS = [
+  {
+    value: "generic",
+    label: "Generic",
+    hint: "a delegating assistant, and the one to start from",
+    about: "A delegating assistant: it answers over A2A on a Workers AI model, hands self-contained work to a research sub-agent, and keeps one continuous, self-compacting conversation per caller with a durable memory. Its own Worker, its own wrangler config, its own tenant."
+  }
+];
+var blueprintOf = (arg) => BLUEPRINTS.find((blueprint2) => blueprint2.value === arg.toLowerCase());
+
+// src/agent/offer/capabilities.ts
+var CAPABILITIES = [
+  {
+    value: "browser",
+    label: "Read web pages",
+    hint: "@dynamicagents/plugins/browser — needs the BROWSER binding"
+  }
+];
+
+// src/agent/names.ts
+var TENANT_RE = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+var TENANT_MIN = 2;
+var TENANT_MAX = 32;
+var LANGUAGE = /* @__PURE__ */ new Set([
+  "arguments",
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "constructor",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "eval",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "instanceof",
+  "interface",
+  "let",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "static",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield"
+]);
+var RESERVED = /* @__PURE__ */ new Set([
+  "run",
+  "pipeline",
+  "step",
+  "env",
+  "ctx",
+  "name",
+  "copy",
+  "manifest",
+  "plugins",
+  "soul"
+]);
+var COLLIDES = /* @__PURE__ */ new Map([
+  ["a2a", "a2a"],
+  ["agent-model", "agentModel"],
+  ["create-a2-a-worker", "createA2AWorker"],
+  ["define-agent", "defineAgent"],
+  ["handle-artifact-route", "handleArtifactRoute"],
+  ["host-manifest", "hostManifest"],
+  ["manifest", "manifest"],
+  ["plugins", "plugins"],
+  ["step", "StepAgent"],
+  ["task", "TaskHost"],
+  ["turn-task", "turnTask"]
+]);
+var MODEL_ID_RE = /^@cf\/[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*$/;
+function validateTenant(input) {
+  const value = input.trim();
+  if (value === "") return "Name it something.";
+  if (value.length < TENANT_MIN || value.length > TENANT_MAX) {
+    return `Between ${TENANT_MIN} and ${TENANT_MAX} characters.`;
+  }
+  if (!TENANT_RE.test(value)) {
+    return "Lowercase letters, digits and single dashes, starting with a letter — like `support` or `release-notes`.";
+  }
+  const camel = camelCase(value);
+  if (LANGUAGE.has(camel)) {
+    return `\`${value}\` is a name JavaScript will not let the generated code declare. Pick another.`;
+  }
+  const collision = COLLIDES.get(value);
+  if (collision !== void 0) {
+    return `\`${value}\` would generate \`${collision}\`, which a generated module already has by that name. Pick another.`;
+  }
+  if (RESERVED.has(camel)) {
+    return `\`${value}\` is a name the generated classes already use for something else. Pick another.`;
+  }
+  return void 0;
+}
+function validateModelId(input) {
+  const value = input.trim();
+  if (value === "") return "Paste a model id.";
+  if (!MODEL_ID_RE.test(value)) {
+    return "A Workers AI model id looks like `@cf/<org>/<model>`.";
+  }
+  return void 0;
+}
+var words = (tenant2) => tenant2.split("-");
+var displayName = (tenant2) => words(tenant2).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+var pascalCase = (tenant2) => words(tenant2).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+var camelCase = (tenant2) => {
+  const [first, ...rest] = words(tenant2);
+  return (first ?? "") + rest.map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+};
+function names(tenant2) {
+  const pascal = pascalCase(tenant2);
+  const screaming = tenant2.replace(/-/g, "_").toUpperCase();
+  return {
+    tenant: tenant2,
+    pascal,
+    camel: camelCase(tenant2),
+    screaming,
+    dir: `src/agents/${tenant2}`,
+    hostClass: `${pascal}Host`,
+    workflowClass: `${pascal}Workflow`,
+    agentClass: `${pascal}Agent`,
+    childClass: `${pascal}Child`,
+    workflowBinding: `${screaming}_WORKFLOW`,
+    workflowName: `${tenant2}-workflow`
+  };
+}
+
+// src/cli/kinds.ts
+var KINDS = [
+  {
+    value: "gate",
+    label: "Gate",
+    hint: "where people and APIs reach your agents",
+    about: "Gates are the interfaces humans or APIs interact with, like a Slack, WhatsApp or API gate.",
+    ready: false
+  },
+  {
+    value: "leader",
+    label: "Leader",
+    hint: "creates, edits and evaluates a group of agents",
+    about: "A leader is a powerful agent that can create, edit and evaluate a group of agents.",
+    ready: false
+  },
+  {
+    value: "agent",
+    label: "Agent",
+    hint: "one agent, in a Worker of its own",
+    about: "An agent in a deployable Cloudflare Worker of its own: its own wrangler config, its own bindings, its own signing key, reached over A2A as its own tenant. Nothing it does can affect another agent, and several can be brought into one Worker later.",
+    ready: true
+  }
+];
+var kindOf = (arg) => KINDS.find((kind2) => kind2.value === arg.toLowerCase());
+
+// src/train.ts
+var TRAIN = {
+  core: ">=0.17.0 <0.18.0",
+  plugins: ">=0.17.0 <0.18.0"
+};
+var RUNTIME = {
+  "@cloudflare/think": ">=0.21.0 <0.22.0",
+  agents: ">=0.30.0 <0.31.0",
+  ai: "^7.0.88",
+  /**
+   * Think's own non-optional peer, and core's. A generated project gets it
+   * whichever way, since npm installs a missing peer, so what naming it buys is
+   * a manifest that says what the project runs on.
+   */
+  "@cloudflare/computer": "^0.5.1",
+  "workers-ai-provider": "^4.0.0",
+  /** The A2A protocol's own package: its constants and types. */
+  "@a2a-js/sdk": "^1.2.0",
+  /** A sub-agent's spec declares its input schema in zod. */
+  zod: "^4.6.5"
+};
+var TOOLCHAIN = {
+  /**
+   * Paired with {@link WORKERD} as much as `wrangler` is: this pins the
+   * miniflare a generated project's tests boot, and that runtime reads the
+   * compatibility date too.
+   */
+  "@cloudflare/vitest-plugin": "^1.4.7",
+  "@types/node": "^24.19.2",
+  eslint: "^10.10.0",
+  prettier: "^3.9.6",
+  typescript: "^6.0.3",
+  "typescript-eslint": "^8.72.0",
+  /**
+   * **4 until the Workers pool takes 5**, whatever this package tests itself
+   * with. A generated project tests through `@cloudflare/vitest-plugin`, and
+   * on vitest 5 that pool crashes workerd mid-run and the test file it was
+   * running goes unreported — `cloudflare/workers-sdk#16331`, and core's own
+   * `AGENTS.md` is the home of that ceiling and of what to re-check before
+   * lifting it. The whole train sits below it or none of it does, so this
+   * moves with core, plugins and starter and not before them. The caret is
+   * what holds a new project clear in the meantime: an install takes the
+   * newest the range allows, and on `^4` that can never be 5.
+   */
+  vitest: "^4.1.11",
+  wrangler: "^4.152.0"
+};
+var WORKERD = "1.20261019.1";
+function compatibilityDateOf(workerd) {
+  const stamp = /^\d+\.(\d{4})(\d{2})(\d{2})\.\d+$/.exec(workerd);
+  if (stamp === null) {
+    throw new Error(
+      `train: "${workerd}" is not a workerd version (1.YYYYMMDD.N)`
+    );
+  }
+  const [, year, month, day] = stamp;
+  return `${year}-${month}-${day}`;
+}
+var COMPATIBILITY_DATE = compatibilityDateOf(WORKERD);
+var NODE_ENGINE = ">=24";
+var NODE_VERSION = "24";
+var DEFAULT_MODEL_ID = "@cf/zai-org/glm-5.3-flash";
+var MODELS_URL = "https://developers.cloudflare.com/ai/models/";
+
+// src/cli/messages.ts
+var WEBSITE = "https://dynamicagents.dev";
+var title = (version2) => `Dynamic Agents · create-dynamicagents v${version2}`;
+var question = "What would you like to build?";
+var whichAgent = "Which agent do you want to create?";
+var workInProgress = (kind2) => `${kind2.label} scaffolding is a work in progress. Follow updates at ${WEBSITE}`;
+var nothingBuilt = "Nothing was built.";
+var width = Math.max(...KINDS.map((kind2) => kind2.value.length));
+var choices = () => KINDS.map((kind2) => `  ${kind2.value.padEnd(width)}  ${kind2.hint}`).join("\n");
+var COMMAND = "npm create dynamicagents@latest";
+var DASH_NOTE = "The `--` is npm's, not ours: without it npm keeps the flags for itself.";
+var FLAGS = [
+  {
+    key: "name",
+    spelled: "--name <tenant>",
+    answers: "its tenant id, and every name derived from it"
+  },
+  {
+    key: "description",
+    spelled: "--description <line>",
+    answers: "one line for its card, and its soul's first line"
+  },
+  {
+    key: "dir",
+    spelled: "--dir <path>",
+    answers: "where to write it, if not a directory named for it"
+  },
+  {
+    key: "model",
+    spelled: "--model <id>",
+    answers: "a Workers AI model id — see the catalogue"
+  },
+  {
+    key: "subagent",
+    spelled: "--no-subagent",
+    answers: "leave out the sub-agent it hands research to"
+  },
+  {
+    key: "browser",
+    spelled: "--browser",
+    answers: "install the browser plugin, its binding, its skill"
+  },
+  { key: "yes", spelled: "--yes", answers: "do not ask for confirmation" },
+  {
+    key: "dry-run",
+    spelled: "--dry-run",
+    answers: "print what would be written, and write nothing"
+  },
+  { key: "help", spelled: "--help, -h", answers: "what you are reading" },
+  {
+    key: "version",
+    spelled: "--version, -v",
+    answers: "the version that would run"
+  }
+];
+var flagColumn = Math.max(...FLAGS.map((flag) => flag.spelled.length));
+var listed = () => FLAGS.map(
+  (flag) => `  ${flag.spelled.padEnd(flagColumn)}  ${flag.answers}`
+).join("\n");
+var example = (indent) => [
+  `${indent}${COMMAND} agent ${BLUEPRINTS[0].value} <dir> -- \\`,
+  `${indent}  --name <tenant> --description "<one line>" --yes`
+].join("\n");
+var help = (version2) => [
+  title(version2),
+  "",
+  "Create gates, leaders and agents on Dynamic Agents.",
+  "",
+  "Usage",
+  `  ${COMMAND}`,
+  "      Ask what to build, and ask for every answer.",
+  "",
+  example("  "),
+  "      Answer up front. A usable answer is not asked for; one that",
+  "      will not do is said where it was given.",
+  "",
+  "What it can build",
+  choices(),
+  "",
+  "Flags",
+  listed(),
+  "",
+  DASH_NOTE
+].join("\n");
+var noTerminal = () => [
+  "No terminal to ask in, so name what to build and answer for it:",
+  "",
+  choices(),
+  "",
+  example(""),
+  "",
+  "Flags",
+  listed(),
+  "",
+  DASH_NOTE
+].join("\n");
+var badArgument = (trouble) => [
+  "unknown" in trouble ? unknownFlags(trouble.unknown) : trouble.message,
+  "",
+  "Flags",
+  listed(),
+  "",
+  DASH_NOTE
+].join("\n");
+var unknownFlags = (flags2) => {
+  const quoted2 = flags2.map((flag) => `\`${flag}\``).join(", ");
+  return flags2.length === 1 ? `${quoted2} is not a flag this takes.` : `${quoted2} are not flags this takes.`;
+};
+var badValue = (named, value, problem) => [
+  `\`${named} ${JSON.stringify(value)}\` will not do:`,
+  "",
+  `  ${problem}`
+].join("\n");
+var unknownKind = (arg) => [`"${arg}" is not something to build. Name one of:`, "", choices()].join(
+  "\n"
+);
+var unknownBlueprint = (arg) => [
+  `"${arg}" is not an agent this can create. Name one of:`,
+  "",
+  BLUEPRINTS.map((b) => `  ${b.value}  ${b.hint}`).join("\n")
+].join("\n");
+var askTenant = "What should the agent be called?";
+var tenantPlaceholder = "support";
+var askDescription = "In one line, what does it do?";
+var descriptionPlaceholder = "Answers product questions from the handbook";
+var askSubAgent = "Give it a sub-agent to hand research to?";
+var askCapabilities = "Anything else it can do? (space to pick, enter for none)";
+var askModel = "Which model should it run on?";
+var defaultModelLabel = `The default — ${DEFAULT_MODEL_ID}`;
+var otherModelLabel = (hyperlinks2) => `Another one — paste an id from ${link(MODELS_URL, MODELS_URL, hyperlinks2)}`;
+var askModelId = "Paste the model id";
+var link = (url, label, hyperlinks2) => hyperlinks2 ? `\x1B]8;;${url}\x07${label}\x1B]8;;\x07` : url;
+var confirmWrite = "Write it?";
+function tree(dir, files) {
+  const top = files.filter((file) => !file.path.includes("/")).map((file) => file.path);
+  const dirs = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const at = file.path.lastIndexOf("/");
+    if (at === -1) continue;
+    const parent = file.path.slice(0, at);
+    dirs.set(parent, (dirs.get(parent) ?? 0) + 1);
+  }
+  const lines = [`${dir}/`];
+  for (const [parent, count] of dirs) {
+    lines.push(`  ${parent}/ — ${count === 1 ? "one file" : `${count} files`}`);
+  }
+  lines.push(`  ${top.join(" · ")}`);
+  return lines.join("\n");
+}
+function nextSteps(dir, tenant2) {
+  return [
+    `cd ${dir}`,
+    "npm run keygen            # one signing key — put it in .env",
+    "npm run check             # types, format, lint, typecheck",
+    "npm test                  # the suite, in real workerd",
+    "npm run dev               # and when you are ready: npm run deploy",
+    "",
+    `Then write src/agents/${tenant2}/soul.ts — it is the one part nobody else`,
+    `can write for you — and register the tenant \`${tenant2}\` with your`,
+    "gatekeeper at https://<your-worker>/a2a",
+    "",
+    "README.md has the rest; AGENTS.md has the rules."
+  ].join("\n");
+}
+var installing = "Installing";
+var installed = "Installed";
+var wrote = (dir) => `Wrote ${dir}`;
+var outroLine = (name) => `${name} is ready. Write its soul, then deploy it.`;
+var dryRun = "Nothing was written: this was a dry run.";
+var notEmpty = (named) => `\`${named}\` already has something in it. Name a directory that does not exist yet, or an empty one.`;
+var cannotRead = (named, problem) => [
+  `\`${named}\` cannot be read, so there is no telling what is there:`,
+  "",
+  `  ${problem}`,
+  "",
+  "Name a directory that does not exist yet, or one you can write to."
+].join("\n");
+var noDescription = () => "Say in one line what the agent does: it goes on its card, and it is the first line of its soul.";
+var describeTooLong = () => "One line, please — this goes on the agent's card. Say the rest in its soul once it exists.";
+var describeOneLine = () => "One line means one line: no line breaks. It goes on the agent's card and into its source. Say the rest in its soul once it exists.";
+var finishByHand = (dir, problem) => [
+  problem,
+  "",
+  `The project is written. Finish it with:`,
+  "",
+  `  cd ${dir}`,
+  "  npm install",
+  "  npx wrangler types"
+].join("\n");
+var notInstalled = (name) => `${name} is written, but its install did not finish. Run the commands above, then README.md has the rest.`;
+
+// src/cli/answers.ts
+var DESCRIPTION_MAX = 200;
+var LINE_BREAK = /[\n\r\u2028\u2029]/;
+var asKind = (raw) => {
+  const kind2 = kindOf(raw);
+  return kind2 === void 0 ? { problem: unknownKind(raw) } : { value: kind2 };
+};
+var asBlueprint = (raw) => {
+  const blueprint2 = blueprintOf(raw);
+  return blueprint2 === void 0 ? { problem: unknownBlueprint(raw) } : { value: blueprint2 };
+};
+var asTenant = (raw) => {
+  const problem = validateTenant(raw);
+  return problem === void 0 ? { value: raw.trim() } : { problem };
+};
+var asDescription = (raw) => {
+  const value = raw.trim();
+  if (value === "") return { problem: noDescription() };
+  if (LINE_BREAK.test(value)) return { problem: describeOneLine() };
+  if (value.length > DESCRIPTION_MAX) return { problem: describeTooLong() };
+  return { value };
+};
+var asModelId = (raw) => {
+  const problem = validateModelId(raw);
+  return problem === void 0 ? { value: raw.trim() } : { problem };
+};
+var whyNot = (judge) => (value) => {
+  const judged = judge(value ?? "");
+  return "problem" in judged ? judged.problem : void 0;
+};
+function replyTo(given, judge, where) {
+  if (given === void 0) {
+    if (where.interactive) return { kind: "ask" };
+    if (where.fallback !== void 0) {
+      return { kind: "use", value: where.fallback };
+    }
+    return { kind: "stop", problem: noTerminal() };
+  }
+  const judged = judge(given);
+  if (!("problem" in judged)) return { kind: "use", value: judged.value };
+  if (where.interactive) {
+    return { kind: "ask", problem: judged.problem, initial: given };
+  }
+  return {
+    kind: "stop",
+    problem: where.named === void 0 ? judged.problem : badValue(where.named, given, judged.problem)
+  };
+}
+
+// src/cli/args.ts
+import { parseArgs } from "node:util";
+var OPTIONS = {
+  name: { type: "string" },
+  description: { type: "string" },
+  dir: { type: "string" },
+  model: { type: "string" },
+  subagent: { type: "boolean" },
+  browser: { type: "boolean" },
+  yes: { type: "boolean" },
+  "dry-run": { type: "boolean" },
+  help: { type: "boolean", short: "h" },
+  version: { type: "boolean", short: "v" }
+};
+var parse = (args) => parseArgs({
+  args: [...args],
+  allowPositionals: true,
+  allowNegative: true,
+  options: OPTIONS
+});
+function unknownIn(args) {
+  const { tokens } = parseArgs({
+    args: [...args],
+    allowPositionals: true,
+    allowNegative: true,
+    strict: false,
+    tokens: true,
+    options: OPTIONS
+  });
+  const declared = new Set(Object.keys(OPTIONS));
+  const unknown = [];
+  for (const token of tokens) {
+    if (token.kind !== "option") continue;
+    if (declared.has(token.name)) continue;
+    if (!unknown.includes(token.rawName)) unknown.push(token.rawName);
+  }
+  return unknown;
+}
+function read(args) {
+  let values;
+  let positionals2;
+  try {
+    ({ values, positionals: positionals2 } = parse(args));
+  } catch (err) {
+    const { code, message } = err;
+    if (code === "ERR_PARSE_ARGS_UNKNOWN_OPTION") {
+      const unknown = unknownIn(args);
+      if (unknown.length > 0) return { want: "trouble", trouble: { unknown } };
+    }
+    return { want: "trouble", trouble: { message } };
+  }
+  if (values.help === true) return { want: "help" };
+  if (values.version === true) return { want: "version" };
+  return { want: "run", flags: values, positionals: positionals2 };
+}
+
+// src/cli/install.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+var NPM_TIMEOUT_MS = 10 * 6e4;
+var needsShell = (platform) => platform === "win32";
+async function npm(args, cwd) {
+  try {
+    await run("npm", args, {
+      cwd,
+      timeout: NPM_TIMEOUT_MS,
+      maxBuffer: 32 * 1024 * 1024,
+      windowsHide: true,
+      shell: needsShell(process.platform)
+    });
+  } catch (err) {
+    const { stderr, message } = err;
+    const detail = (stderr ?? "").trim().split("\n").slice(-12).join("\n");
+    throw new Error(
+      `\`npm ${args.join(" ")}\` failed.
+
+${detail === "" ? message : detail}`
+    );
+  }
+}
+async function installProject(dir, report) {
+  report("Installing dependencies");
+  await npm(["install", "--no-audit", "--no-fund"], dir);
+  report("Generating Worker types");
+  await npm(["exec", "--", "wrangler", "types"], dir);
+}
+
+// src/agent/templates/render.ts
+var MARKER = /^(?:\/\/|#|\*)\s*\$(when|end|block)\b(?:\s+(!?)([A-Za-z]\w*))?\s*$/;
+var TOKEN = /\$[A-Z][A-Z0-9_]*/g;
+function render(source, bindings = {}) {
+  const when = bindings.when ?? {};
+  const tokens = bindings.tokens ?? {};
+  const lines = source.split("\n");
+  const regionNames = /* @__PURE__ */ new Set();
+  const tokenNames = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    const marker = MARKER.exec(line.trim());
+    if (marker === null) {
+      for (const token of line.match(TOKEN) ?? [])
+        tokenNames.add(token.slice(1));
+      continue;
+    }
+    const [, directive, negated, name] = marker;
+    if (name === void 0) continue;
+    if (directive === "when") regionNames.add(name);
+    else if (directive === "block" && negated !== "!") tokenNames.add(name);
+  }
+  for (const name of Object.keys(when)) {
+    if (!regionNames.has(name)) {
+      throw new Error(`render: no "$when ${name}" region in this template`);
+    }
+  }
+  for (const name of Object.keys(tokens)) {
+    if (!tokenNames.has(name)) {
+      throw new Error(`render: nothing in this template reads "$${name}"`);
+    }
+  }
+  const bound = (name, what) => {
+    const value = tokens[name];
+    if (value === void 0) throw new Error(`render: "${what}" is not bound`);
+    return value;
+  };
+  const kept = [];
+  let open;
+  for (const line of lines) {
+    const marker = MARKER.exec(line.trim());
+    if (marker === null) {
+      if (open === void 0 || open.keep) {
+        kept.push(line.replace(TOKEN, (token) => bound(token.slice(1), token)));
+      }
+      continue;
+    }
+    const [, directive, negated, name] = marker;
+    if (directive === "block") {
+      if (name === void 0 || negated === "!") {
+        throw new Error(`render: "$block" names no token in "${line.trim()}"`);
+      }
+      if (open === void 0 || open.keep) {
+        kept.push(bound(name, `$block ${name}`));
+      }
+      continue;
+    }
+    if (directive === "end") {
+      if (name !== void 0) {
+        throw new Error(`render: "$end" takes no name, got "${line.trim()}"`);
+      }
+      if (open === void 0) throw new Error('render: "$end" without "$when"');
+      open = void 0;
+      continue;
+    }
+    if (name === void 0) {
+      throw new Error(`render: "$when" names no flag in "${line.trim()}"`);
+    }
+    if (open !== void 0) {
+      throw new Error(
+        `render: "$when ${name}" nested inside "$when ${open.name}"`
+      );
+    }
+    const flag = when[name];
+    if (flag === void 0) {
+      throw new Error(`render: "$when ${name}" names an unbound flag`);
+    }
+    open = { name, keep: negated === "!" ? !flag : flag };
+  }
+  if (open !== void 0) {
+    throw new Error(`render: "$when ${open.name}" is never closed`);
+  }
+  return kept.join("\n");
+}
+
+// src/agent/templates/agent/agent.ts.tpl
+var agent_ts_default = 'import type { ThinkModel } from "@cloudflare/think";\nimport type { AgentPlugin } from "@dynamicagents/core";\nimport { StepAgent } from "@dynamicagents/core/agent";\n// $when subAgent\nimport type { SubAgentClass } from "@dynamicagents/core/subagent";\n// $end\nimport type { StepJob } from "@dynamicagents/core/workflow";\nimport type { ContextConfig } from "agents/context";\nimport type { LanguageModel } from "ai";\nimport { RETRY_BRIEF } from "@/copy";\nimport { agentModel } from "@/model";\n// $when subAgent\nimport { $CHILD_CLASS } from "./children";\n// $end\nimport { $CAMEL } from "./definition";\nimport { plugins } from "./plugins";\nimport { MEMORY, SOUL } from "./soul";\nimport { TUNING } from "./tuning";\n\n/**\n * $NAME.\n *\n * The turn is `@cloudflare/think`\'s, the step job and delegation are\n * `@dynamicagents/core/agent`\'s, and the A2A task around it is `./host.ts`\'s.\n * What is actually *this agent* is the members below plus `./plugins.ts`,\n * `./soul.ts`$SOUL_FILES and `./tuning.ts` — nothing else in this\n * project is specific to it.\n */\nexport class $AGENT_CLASS extends StepAgent<Env> {\n  protected readonly compactAfterTokens = TUNING.compactAfterTokens;\n  protected readonly keepRecentTokens = TUNING.keepRecentTokens;\n\n  override getModel(): ThinkModel {\n    return agentModel(\n      this.env,\n      { modelId: TUNING.modelId, name: this.name },\n      {\n        agent: $CAMEL.tenant,\n        taskId: this.turnTaskId(),\n        phase: "turn"\n      }\n    );\n  }\n\n  /** Compaction runs over a history every task shares, so it has no task. */\n  protected override compactionModel(): LanguageModel {\n    return agentModel(\n      this.env,\n      { modelId: TUNING.compactionModelId, name: this.name },\n      {\n        agent: $CAMEL.tenant,\n        phase: "compaction"\n      }\n    );\n  }\n\n  override configureContext(): ContextConfig[] {\n    return [\n      { label: "soul", provider: { get: async () => SOUL } },\n      { label: "memory", description: MEMORY },\n      ...super.configureContext()\n    ];\n  }\n\n  override getPlugins(): AgentPlugin<Env>[] {\n    return plugins(this.env);\n  }\n\n  // $when subAgent\n  override getSubAgents(): SubAgentClass[] {\n    return [$CHILD_CLASS];\n  }\n\n  // $end\n  /** A retry is told so, and to carry on from what the first attempt left. */\n  protected override formatStepJobInput(job: StepJob): string {\n    return job.attempt > 1 ? `${RETRY_BRIEF}\\n\\n${job.input}` : job.input;\n  }\n}\n';
+
+// src/agent/templates/agent/agent.ts
+var agentTs = (spec2, n3) => render(agent_ts_default, {
+  when: { subAgent: spec2.subAgent },
+  tokens: {
+    NAME: spec2.name,
+    AGENT_CLASS: n3.agentClass,
+    CAMEL: n3.camel,
+    CHILD_CLASS: n3.childClass,
+    // Mid-sentence in the class's doc comment, listing the files that are
+    // actually this agent — so a phrase rather than a region, which would
+    // need a line of its own.
+    SOUL_FILES: spec2.subAgent ? ", `./children.ts`" : ""
+  }
+});
+
+// src/agent/templates/agent/children.ts.tpl
+var children_ts_default = 'import type { ThinkModel } from "@cloudflare/think";\nimport type { AgentPlugin, SubAgentSpec } from "@dynamicagents/core";\nimport { SubAgent } from "@dynamicagents/core/subagent";\nimport { z } from "zod";\nimport { agentModel, turnTask } from "@/model";\nimport { $CAMEL } from "./definition";\nimport { plugins } from "./plugins";\nimport { GENERAL_SOUL } from "./soul";\nimport { TUNING } from "./tuning";\n\n/**\n * The catch-all: any self-contained unit of work with no domain of its own.\n *\n * **Awaited.** Research, drafting and reading a page finish well inside the\n * fifteen minutes a turn can last, so the parent waits for the result in the\n * same turn rather than answering in a later one. A sub-agent that may run\n * longer than a turn declares `detached: true` instead — there is nothing in\n * between.\n *\n * A spec is data; the class below binds it. Core refuses to lend a soul, so a\n * sub-agent\'s identity is written here and nowhere else.\n */\nconst GENERAL: SubAgentSpec<{ task: string }> = {\n  name: "general",\n  description:\n    "Hand a self-contained piece of work to a sub-agent and wait for its result: research, drafting, summarizing. It cannot see this conversation, so put everything it needs in the task.",\n  inputSchema: z.object({\n    task: z\n      .string()\n      .describe(\n        "The work, with everything needed to do it: the sub-agent sees nothing else"\n      )\n  }),\n  soul: GENERAL_SOUL,\n  formatInput: (input) => input.task\n};\n\nexport class $CHILD_CLASS extends SubAgent<Env> {\n  static override spec = GENERAL as SubAgentSpec<never, never>;\n\n  override getModel(): ThinkModel {\n    return agentModel(\n      this.env,\n      { modelId: TUNING.modelId, name: this.name },\n      {\n        agent: $CAMEL.tenant,\n        taskId: turnTask(this.activeTurnMetadata),\n        phase: "subagent",\n        subAgent: "$CHILD_CLASS"\n      }\n    );\n  }\n\n  override getPlugins(): AgentPlugin<Env>[] {\n    return plugins(this.env);\n  }\n}\n';
+
+// src/agent/templates/agent/children.ts
+var childrenTs = (n3) => render(children_ts_default, {
+  tokens: { CAMEL: n3.camel, CHILD_CLASS: n3.childClass }
+});
+
+// src/agent/templates/agent/definition.ts.tpl
+var definition_ts_default = 'import { defineAgent } from "@dynamicagents/core/worker";\nimport { manifest } from "./manifest";\n\n/**\n * How this agent is reached: its tenant id, its card and its Durable Object,\n * declared once. `src/index.ts` mounts the tenant from this.\n *\n * The tenant id is a **public identifier**: a gatekeeper registers against it\n * and it rides in a JWT claim, so changing it later is a re-registration rather\n * than a rename. Every class and binding in this project derives from it.\n */\nexport const $CAMEL = defineAgent({\n  tenant: "$TENANT",\n  manifest,\n  agent: (env: Env) => env.$HOST_CLASS\n});\n';
+
+// src/agent/templates/agent/definition.ts
+var definitionTs = (spec2, n3) => render(definition_ts_default, {
+  tokens: { CAMEL: n3.camel, TENANT: spec2.tenant, HOST_CLASS: n3.hostClass }
+});
+
+// src/agent/templates/text.ts
+var PRINT_WIDTH = 80;
+function quoted(value) {
+  const json = JSON.stringify(value);
+  if (!value.includes('"') || value.includes("'")) return json;
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+function stringProp(key, value, indent = 2) {
+  const pad = " ".repeat(indent);
+  const literal = quoted(value);
+  if (`${pad}${key}: ${literal},`.length <= PRINT_WIDTH) {
+    return `${pad}${key}: ${literal}`;
+  }
+  return `${pad}${key}:
+${pad}  ${literal}`;
+}
+function namedFrom(keyword, names3, from) {
+  const inline = `${keyword} { ${names3.join(", ")} } from ${quoted(from)};`;
+  if (names3.length < 2 || inline.length <= PRINT_WIDTH) return inline;
+  return `${keyword} {
+${names3.map((name) => `  ${name}`).join(",\n")}
+} from ${quoted(from)};`;
+}
+function assigned(left, value, indent = 2) {
+  const pad = " ".repeat(indent);
+  const literal = quoted(value);
+  const inline = `${pad}${left} = ${literal};`;
+  if (inline.length <= PRINT_WIDTH) return inline;
+  return `${pad}${left} =
+${pad}  ${literal};`;
+}
+function arrayProp(key, values, indent = 2) {
+  const pad = " ".repeat(indent);
+  const items = values.map(quoted);
+  const inline = `${pad}${key}: [${items.join(", ")}],`;
+  if (inline.length <= PRINT_WIDTH) {
+    return `${pad}${key}: [${items.join(", ")}]`;
+  }
+  return `${pad}${key}: [
+${items.map((item) => `${pad}  ${item}`).join(",\n")}
+${pad}]`;
+}
+var jsonArrayProp = (key, values, indent = 2) => arrayProp(quoted(key), values, indent);
+function jsonObject(entries, indent) {
+  const pad = " ".repeat(indent);
+  const pairs = entries.map(
+    ([key, value]) => `${quoted(key)}: ${quoted(value)}`
+  );
+  const inline = `${pad}{ ${pairs.join(", ")} },`;
+  if (inline.length <= PRINT_WIDTH) return `${pad}{ ${pairs.join(", ")} }`;
+  return `${pad}{
+${pairs.map((pair) => `${pad}  ${pair}`).join(",\n")}
+${pad}}`;
+}
+var jsonFile = (value) => `${JSON.stringify(value, null, 2)}
+`;
+function mdTable(headers, rows) {
+  const widths = headers.map(
+    (header, column) => Math.max(
+      [...header].length,
+      3,
+      ...rows.map((row) => [...row[column] ?? ""].length)
+    )
+  );
+  const pad = (cell, column) => cell + " ".repeat(widths[column] - [...cell].length);
+  const render2 = (cells) => `| ${cells.map((cell, column) => pad(cell, column)).join(" | ")} |`;
+  return [
+    render2(headers),
+    `| ${widths.map((width2) => "-".repeat(width2)).join(" | ")} |`,
+    ...rows.map(render2)
+  ].join("\n");
+}
+
+// src/agent/templates/agent/host.ts.tpl
+var host_ts_default = 'import { TaskHost } from "@dynamicagents/core/task";\nimport { copy } from "@/copy";\n\n/**\n * This tenant\'s task host: it owns each A2A task, keyed by the verified caller,\n * and `$WORKFLOW_CLASS` (`./workflow.ts`) runs it as steps. The mechanism is\n * core\'s `/task`; what is here is the words it says and the bindings it uses.\n *\n * **Cancellation is decided by core\'s guarded write, never by a probe.** The\n * ledger flips a task to `canceled` in one write and refuses every later write\n * against it, saying so. A hook added here runs after that flip and acts on it;\n * it never reads the task first and decides.\n *\n * Both bindings are typed `: string` rather than inferred, so a test can\n * subclass this host and point it at a scripted pipeline — `test/worker.ts`\n * does exactly that.\n */\nexport class $HOST_CLASS extends TaskHost<Env> {\n  protected readonly copy = copy;\n  // $block HOST_BINDINGS\n}\n';
+
+// src/agent/templates/agent/host.ts
+var hostTs = (n3) => render(host_ts_default, {
+  tokens: {
+    HOST_CLASS: n3.hostClass,
+    WORKFLOW_CLASS: n3.workflowClass,
+    // Both break after the `=` once the line passes the print width, which a
+    // long tenant id does on its own — so they keep `assigned` and arrive as
+    // a block. `../../formatting.spec.ts` sweeps the ids that reach it.
+    HOST_BINDINGS: [
+      assigned(
+        "protected readonly workflowBinding: string",
+        n3.workflowBinding
+      ),
+      assigned("protected readonly hostBinding: string", n3.hostClass)
+    ].join("\n")
+  }
+});
+
+// src/agent/templates/agent/manifest.ts.tpl
+var manifest_ts_default = 'import type { AgentManifest } from "@dynamicagents/core/a2a";\n\n/**\n * The transport-independent half of this agent\'s AgentCard — everything that\n * does not depend on the request origin. Core adds `supportedInterfaces` (the\n * deployment\'s `/a2a` url, tagged with this agent\'s tenant id) and the security\n * scheme. It is served through `GetExtendedAgentCard`, since the well-known\n * path carries the deployment\'s stub card — `src/host-manifest.ts`.\n *\n * `AgentManifest` is core\'s, derived from the A2A SDK\'s `AgentCard` rather than\n * hand-declared, so a protocol field that gains a requirement fails the build\n * here instead of silently going unadvertised.\n *\n * **The skills are what this agent has.** Adding a capability in\n * `./plugins.ts`, or a sub-agent in `./children.ts`, means a skill here;\n * removing one means removing it. Each skill\'s `inputModes`, `outputModes` and\n * `securityRequirements` are empty, which means "inherit the card\'s" — the\n * default modes below, and the gatekeeper JWT.\n */\nexport const manifest: AgentManifest = {\n  // $block CARD_IDENTITY\n  version: "0.1.0",\n  // `extensions` is a required (repeated) protobuf field in v1.0, and this\n  // agent declares no protocol extensions, so it stays empty.\n  capabilities: { streaming: false, pushNotifications: true, extensions: [] },\n  defaultInputModes: ["text/plain"],\n  defaultOutputModes: ["text/plain"],\n  skills: [\n    // $block SKILLS\n  ]\n};\n';
+
+// src/agent/templates/agent/manifest.ts
+var CHAT = {
+  id: "chat",
+  name: "Chat",
+  description: "Answer the caller on a Workers AI model, calling tools when useful.",
+  tags: ["chat", "assistant"]
+};
+var DELEGATE = {
+  id: "delegate",
+  name: "Research and self-contained work",
+  description: "Hand self-contained pieces of a request to sub-agents, several at once when it splits cleanly, then compose their results into one answer.",
+  tags: ["research", "delegation"]
+};
+var BROWSE = {
+  id: "browse",
+  name: "Browse the web",
+  description: "Read and scrape live web pages — render a page as Markdown, extract structured data, or list its links.",
+  tags: ["web", "browser"]
+};
+var skill = (it) => {
+  const props = [
+    stringProp("id", it.id, 6),
+    stringProp("name", it.name, 6),
+    stringProp("description", it.description, 6),
+    `      tags: [${it.tags.map(quoted).join(", ")}]`,
+    "      examples: []",
+    "      inputModes: []",
+    "      outputModes: []",
+    "      securityRequirements: []"
+  ];
+  return `    {
+${props.join(",\n")}
+    }`;
+};
+function manifestTs(spec2) {
+  const skills = [
+    CHAT,
+    ...spec2.subAgent ? [DELEGATE] : [],
+    ...spec2.capabilities.includes("browser") ? [BROWSE] : []
+  ];
+  return render(manifest_ts_default, {
+    tokens: {
+      /**
+       * Trailing comma included, and it has to be: a block owns the separators
+       * on its own boundaries, because `trailingComma: "none"` has prettier
+       * strip a comma before what it reads as the last property, and a comment
+       * marker is not a property it can read.
+       */
+      CARD_IDENTITY: `${[
+        stringProp("name", spec2.name),
+        stringProp("description", spec2.description)
+      ].join(",\n")},`,
+      SKILLS: skills.map(skill).join(",\n")
+    }
+  });
+}
+
+// src/agent/templates/agent/plugins.ts.tpl
+var plugins_ts_default = 'import type { AgentPlugin } from "@dynamicagents/core";\n// $when browser\nimport { browser } from "@dynamicagents/plugins/browser";\n// $end\n\n/**\n * The one file you edit to add or remove a capability for this agent.\n *\n * Delete a line and that module leaves the bundle entirely. Nothing in core\n * imports a plugin, and `@dynamicagents/plugins` has no root barrel — the bare\n * specifier does not resolve — so what the agent carries is what is listed\n * here.\n *\n * A plugin declares the bindings and secrets it needs, and core checks them\n * when the agent starts: an installed plugin whose binding is missing from\n * `wrangler.jsonc` fails with a sentence naming the plugin, rather than at the\n * first tool call inside a request someone is waiting on. So a line here and a\n * binding there arrive together.\n *\n * What the model is told about a capability comes from the plugin itself, not\n * from `./soul.ts`: removing a line removes its advice with it.\n * $when subAgent\n *\n * The agent and its `general` sub-agent install the same list. Files are\n * Think\'s own workspace, in each object\'s SQLite, so there is nothing to\n * install for them.\n * $end\n */\n// $when browser\nexport const plugins = (env: Env): AgentPlugin<Env>[] => [\n  // Read web pages. Needs the `BROWSER` binding in wrangler.jsonc.\n  browser({ binding: env.BROWSER })\n];\n// $end\n// $when !browser\nexport const plugins = (_env: Env): AgentPlugin<Env>[] => [\n  // Nothing installed yet. Each capability is one line here plus its binding\n  // in wrangler.jsonc plus a skill on the card in ./manifest.ts — for example:\n  //\n  //   import { browser } from "@dynamicagents/plugins/browser";\n  //   browser({ binding: env.BROWSER })\n  //\n  // The parameter is `_env` only because nothing reads it yet; the first\n  // plugin that needs a binding takes the underscore off.\n];\n// $end\n';
+
+// src/agent/templates/agent/plugins.ts
+var pluginsTs = (spec2) => render(plugins_ts_default, {
+  when: {
+    browser: spec2.capabilities.includes("browser"),
+    subAgent: spec2.subAgent
+  }
+});
+
+// src/agent/templates/agent/soul.ts.tpl
+var soul_ts_default = 'import { ASK_GUIDANCE } from "@/copy";\n\n/**\n * This agent\'s soul — its identity and its operating rules.\n *\n * **This file is yours.** Core ships no prompt copy at all, deliberately: a run\n * must never execute under an identity nobody chose. What is below is a first\n * draft from one line of description — read it, and make it say what this agent\n * actually is.\n *\n * **Nothing about a capability belongs here.** Every installed plugin tells the\n * model what it can do in a context block of its own$SUBAGENT_NOTE, so removing one removes\n * its advice with it and this file never mentions something the agent cannot\n * do.\n */\nexport const SOUL = [\n  $IDENTITY_LINE,\n  "You are reached over the A2A protocol through the Dynamic Agents gatekeeper, on behalf of a person using whatever gate they came in through. Keep replies concise and actionable.",\n  "If you cannot do something, or you lack the information, say so plainly rather than guessing.",\n  \'A user turn can be wrapped by the gatekeeper in a `<turn from="Name" id="UID" channel="…" at="…">…</turn>` tag — treat those attributes as the authoritative speaker identity, and never author `<turn>` tags yourself.\',\n  "The `caller` block only identifies which gatekeeper-agent dispatched this conversation, verified by the gatekeeper JWT — it is not the person speaking to you. Rely on the `<turn>` tag for that.",\n  "You keep one continuous conversation with this caller across everything they ask, and a durable `memory` block of stable facts. Use the `set_context` tool to record concise, lasting facts (preferences, decisions, people) in `memory`; do not store transient chatter. `search_history` finds what was said earlier, even once it has scrolled out of view.",\n  "Use your tools when they help answer the request, and never fabricate a tool result.",\n  "",\n  ASK_GUIDANCE\n].join("\\n");\n\n/** What the model is told the `memory` block is for. */\nexport const MEMORY =\n  "Stable facts about this caller worth keeping across conversations: preferences, decisions, people. Not transient chatter.";\n// $when subAgent\n\n/**\n * The `general` sub-agent\'s soul.\n *\n * Distinct from the agent\'s own, and the distinction is structural rather than\n * stylistic: a sub-agent has no view of this conversation beyond the task it is\n * handed, so writing it as though it did is how it ends up asking a follow-up\n * question nobody will ever read.\n */\nexport const GENERAL_SOUL = [\n  "You are a sub-agent. You are given a single, self-contained task with all necessary context supplied inline.",\n  "Complete exactly that task and return a concise, direct result.",\n  "Your result is raw material, not a reply: a parent agent composes it — often with other sub-agents\' results — into the single answer the person actually sees. You are never speaking to that person. Return only the substance: no greeting, no preamble, no restating the task, no sign-off.",\n  "You have no memory of past conversations and no access to any conversation beyond what the task says.",\n  "Do not ask follow-up questions; work only from what you are given.",\n  "Use your tools when they help, and never fabricate a tool result."\n].join("\\n");\n// $end\n';
+
+// src/agent/templates/agent/soul.ts
+function soulTs(spec2) {
+  return render(soul_ts_default, {
+    when: { subAgent: spec2.subAgent },
+    tokens: {
+      /**
+       * The identity line, as a complete quoted literal rather than as bare
+       * text in a hand-written `"…"`. A description may hold a double quote —
+       * see the `LINE_BREAK` comment in `../../../cli/answers.ts` — and
+       * `quoted()` is what picks the quote style and the escaping for it. The
+       * two spaces of indentation are the file's, not this helper's.
+       */
+      IDENTITY_LINE: quoted(`You are ${spec2.name}. ${spec2.description}`),
+      // Mid-sentence, and across a line break inside a block comment, which is
+      // why it is a phrase and not a region.
+      SUBAGENT_NOTE: spec2.subAgent ? ", and each sub-agent in its\n * tool's description" : ""
+    }
+  });
+}
+
+// src/agent/templates/agent/tuning.ts.tpl
+var tuning_ts_default = "import type { Reconcile } from \"@dynamicagents/core/workflow\";\n\n/**\n * What this agent tunes. Core ships no numbers, so each one here is chosen.\n *\n * Plain exported values rather than anything resolved at import time: on\n * Workers there is no `env` at module scope, and the classes read these when an\n * object runs.\n */\nexport interface AgentTuning {\n  /**\n   * The Workers AI model the turn runs on. It must call tools reliably over a\n   * long context, because a turn ends when the model stops calling them.\n   * Every id is at $MODELS_URL\n   */\n  modelId: string;\n  /**\n   * The model compaction summarizes with, and **the turn waits for it** — so\n   * this is a wall-clock decision on every compaction, not a detail. A smaller\n   * model is the usual answer; a large conversation is where a small one starts\n   * timing out.\n   */\n  compactionModelId: string;\n  /**\n   * Compact once the conversation's estimate crosses this.\n   *\n   * Compaction is also when Think re-renders the system prompt: until the next\n   * one, the agent reads the soul and the memory as they stood when the prompt\n   * was last rendered, no matter what has been deployed or written since.\n   */\n  compactAfterTokens: number;\n  /** The recent tail compaction keeps verbatim. */\n  keepRecentTokens: number;\n  /**\n   * How long the pipeline waits for its step job's next event before it pulls\n   * the agent and the host for whatever it has not read. That is what an event\n   * the platform accepts and never delivers costs: at worst `maxMs`, instead of\n   * a task that waits for it forever.\n   *\n   * A wait that finds nothing doubles the next one, up to `maxMs`, so a\n   * question left open for days costs a few hundred wakes out of the ten\n   * thousand steps a Workflow instance holds. Lower `afterMs` to notice a lost\n   * event sooner, at more wakes per task.\n   */\n  reconcile: Reconcile;\n}\n\n/**\n * Tight on purpose$WHY_TIGHT.\n * Raise `compactAfterTokens` when the agent keeps losing something it needed,\n * and watch what the turn costs.\n *\n * Watch the prompt too, not only the cost: that number is how stale a long\n * conversation's system prompt can get as much as it is how much each call\n * carries, and a conversation that never reaches it runs to its end on the\n * soul and the memory it started with.\n */\nexport const TUNING: AgentTuning = {\n  modelId: $MODEL_ID,\n  compactionModelId: $MODEL_ID,\n  compactAfterTokens: 16_000,\n  keepRecentTokens: 5_000,\n  reconcile: { afterMs: 5 * 60_000, maxMs: 30 * 60_000 }\n};\n";
+
+// src/agent/templates/agent/tuning.ts
+var tuningTs = (spec2) => render(tuning_ts_default, {
+  tokens: {
+    // A pin, read where it is written rather than copied into the template.
+    MODELS_URL,
+    // Both model ids, as complete quoted literals: a model id comes from the
+    // catalogue or from `--model`, so `quoted()` picks the quoting for it.
+    MODEL_ID: quoted(spec2.modelId),
+    WHY_TIGHT: spec2.subAgent ? ": a delegating agent accumulates sub-agent results fast" : ": a long history is re-sent on every call of the turn"
+  }
+});
+
+// src/agent/templates/agent/workflow.ts.tpl
+var workflow_ts_default = 'import type { WorkflowEvent, WorkflowStep } from "cloudflare:workers";\nimport {\n  TaskWorkflow,\n  type PipelineResult,\n  type TaskParams,\n  type TaskStep\n} from "@dynamicagents/core/workflow";\nimport { TUNING } from "./tuning";\n\n/**\n * This tenant\'s pipeline: one step, the whole task, on the caller\'s own\n * `$AGENT_CLASS`. A step before it or after it — a triage, a judge, a\n * second opinion — goes here, and each gets its own `step.agent(...)` call.\n *\n * The step agent is named by its **binding**, never imported: a pipeline that\n * imported the class would pull that agent\'s whole module graph — plugins\n * included — into every bundle this pipeline is part of. Typed `: string` so a\n * test can point it at a scripted agent.\n *\n * `run()` is declared here, as every pipeline must declare it: the runtime\n * resolves the entrypoint on this class, not on its base.\n */\nexport class $WORKFLOW_CLASS extends TaskWorkflow<Env> {\n  // $block STEP_AGENT\n\n  override run(event: WorkflowEvent<TaskParams>, step: WorkflowStep) {\n    return super.run(event, step);\n  }\n\n  protected async pipeline(\n    event: WorkflowEvent<TaskParams>,\n    step: TaskStep\n  ): Promise<PipelineResult> {\n    const reply = await step.agent("main", {\n      agent: this.$CAMEL,\n      input: event.payload.text,\n      reconcile: TUNING.reconcile\n    });\n    return { reply };\n  }\n}\n';
+
+// src/agent/templates/agent/workflow.ts
+var workflowTs = (n3) => render(workflow_ts_default, {
+  tokens: {
+    WORKFLOW_CLASS: n3.workflowClass,
+    AGENT_CLASS: n3.agentClass,
+    CAMEL: n3.camel,
+    // Breaks after the `=` past the print width, and the field's own name is
+    // derived too, so the whole line is laid out here.
+    STEP_AGENT: assigned(
+      `protected readonly ${n3.camel}: string`,
+      n3.agentClass
+    )
+  }
+});
+
+// src/agent/templates/merge-notes.ts
+var mergeSteps = (dir) => [
+  {
+    path: `${dir}/`,
+    what: "Copy the whole directory across. Nothing in it reaches outside itself except `@/copy` and `@/model`, which the other project already has."
+  },
+  {
+    path: "src/index.ts",
+    what: "Add the `definition` import, the class exports, and the agent to the `agents` array of `createA2AWorker`."
+  },
+  {
+    path: "src/host-manifest.ts",
+    what: "Name the arriving tenant in the description. It is the only place the deployment's card says what is here."
+  },
+  {
+    path: "wrangler.jsonc",
+    what: "Add its two Durable Object bindings and its `workflows` entry, and create its classes in a **new** migration tag — never one already deployed. `Artifacts` is already there: do not create it twice."
+  },
+  {
+    path: "wrangler.jsonc",
+    what: "Then copy every capability binding the arriving config declares — `browser` is the one this creator writes — with its settings as they stand. A plugin declares the bindings it needs and core checks them when the agent starts, so `plugins.ts` without its binding is an agent that throws on its first request."
+  },
+  {
+    path: "package.json",
+    what: "Union the dependencies. Both projects were generated against the same train, so the ranges agree unless one has been bumped."
+  },
+  {
+    path: ".env.example",
+    what: "Union the secrets, and add any the arriving agent's plugins require to `secrets.required` in wrangler.jsonc."
+  },
+  {
+    path: "test/",
+    what: "Rename the arriving specs as they come across. Every generated project calls them `turn.spec.ts`, `edge.spec.ts`, `soul.spec.ts` and so on, so copying them in overwrites the suite that is already here — `turn.<tenant>.spec.ts`, or a directory per tenant, either reads fine."
+  },
+  {
+    path: "test/worker.ts",
+    what: "Merge rather than copy: the suite runs one test Worker. Add the arriving agent's `Test*` classes, its three bindings to `TestEnv`, its `manifest` import under an alias — both projects import that name — and a second `defineAgent({ tenant, manifest, agent })` to the `agents` array. Without that last one its turn specs call a tenant the test Worker does not serve."
+  },
+  {
+    path: "vitest.config.ts",
+    what: "Add the arriving agent's test-only Durable Object and workflow bindings."
+  },
+  {
+    path: "README.md",
+    what: "It was written for one agent: add the arriving tenant to the registration table and to the list of files worth editing, and stop calling the deployment one agent. A reader who believes the old sentence will register one tenant and wonder where the other went."
+  },
+  {
+    path: "AGENTS.md",
+    what: "The same, starting with the heading and the tenant id in its first lines — and keep this recipe in it, because the next merge is read from there."
+  }
+];
+var MERGE_CAVEAT = "A merge does not move state. Every task, conversation and memory the agent had belongs to the Worker it was deployed as; in the merged Worker it starts empty. Finish or drain what is running before you cut over, and keep the old script deployed until you have.";
+
+// src/agent/templates/project/AGENTS.md.tpl
+var AGENTS_md_default = "# AGENTS.md — working in `$TENANT`\n\nOne Worker, one agent. `$NAME` is a **tenant** of this deployment,\nreached over A2A at `/a2a` with `params.tenant` set to `$TENANT`.\n\nAlmost nothing here is framework. The turn is [`@cloudflare/think`][think]'s;\nthe A2A task, the workflow that runs its steps, the step job and delegation to\nsub-agents are [`@dynamicagents/core`][core]'s; optional capabilities are\n[`@dynamicagents/plugins`][plugins]. What lives here is what those deliberately\nrefuse to ship — the words, the numbers, the capabilities this agent has, and\nwhich steps its task runs.\n\n[think]: https://www.npmjs.com/package/@cloudflare/think\n[core]: https://github.com/dynamicagents/core\n[plugins]: https://github.com/dynamicagents/plugins\n\n**A paid Cloudflare Workers plan is a requirement**, not a recommendation: the\nmodel this agent runs on is not served on the free tier$BROWSER_TOO. There is\nno free-tier path in this project.\n\n---\n\n## Where a thing goes\n\n$WHERE_TABLE\n\nIf you find yourself writing durable-execution logic here, that is the signal it\nbelongs in core instead.\n\n**The soul is yours.** Core ships no prompt copy at all, deliberately: a run\nmust never execute under an identity nobody chose. `soul.ts` was seeded from one\nline of description — read it, and make it say what this agent actually is.\n\n---\n\n## Working here\n\n```bash\nnpm run keygen   # one signing key for this deployment — see .env.example\nnpm run check    # wrangler types, prettier, eslint, tsc (src and test)\nnpm test         # vitest, inside real workerd\nnpm run dev      # local\nnpm run deploy   # and register the tenant with your gatekeeper\n```\n\n`npm test` alone will not catch a type error — vitest transpiles specs without\ntypechecking them — so run `check` before you push. `check` starts with\n`wrangler types --check`, which fails on a stale `worker-configuration.d.ts`:\nrun `npm run types` after any change to `wrangler.jsonc`.\n\n### The tests, and what each is for\n\n$TESTS_TABLE\n\nNothing in the suite reaches the network or a real model: `test/worker.ts` is\nthis Worker with the agent's model swapped for a scripted one, and\n`createAgentHarness` from `@dynamicagents/core/testing` drives a turn the way a\ngatekeeper does. A spec that wants a real model needs a recorded cassette —\n`@dynamicagents/core/testing` ships the recorder; it is deliberately not wired\nup here.\n\n---\n\n## Two things that are easy to get wrong\n\n**1. Cancellation is decided by the guarded write, never by a probe.** Core's\ntask ledger flips a task to `canceled` in one guarded write, and every later\nwrite is refused against it and says so. Read those answers. Calling `getTask`\nfirst and acting second reopens a window in which a cancel lands and the\ngatekeeper still gets a `completed` callback.\n\n**2. A migration tag is applied once, ever.** Anything appended to a tag already\ndeployed is never applied, and the failure surfaces at the first request or at\nthe next deploy. Always add a new tag — `wrangler.jsonc` carries the detail,\nincluding what it takes to actually free a deleted class's storage.\n\n---\n\n## Adding a second agent to this Worker\n\nThis project was generated as one agent in its own Worker, which is what makes\nit simple: one bundle, one config, one deployment, and nothing shared with\nanybody else's agent. Nothing stops it holding more, though. A tenant is\nrequired on every request either way, so mounting a second agent is additive\nrather than a redesign.\n\nTwo generated projects merge mechanically because of how they are laid out:\neverything specific to an agent is in its own directory, including its numbers;\noutside that directory the support files — the toolchain config, `src/copy.ts`,\n`src/model.ts` — are identical in every generated project, and what is left is\nthe short list of wiring points below; and every class, binding and workflow\nname derives from the tenant id, so two agents with different tenant ids cannot\ncollide and nothing has to be renamed.\n\nTo bring another generated agent in:\n\n$MERGE_TABLE\n\nThen `npm run types && npm run check && npm test`.\n\n**$MERGE_CAVEAT**\n\nA tenant id is a public identifier: a gatekeeper registers against it and it\nrides in a JWT claim, so renaming one is a re-registration, not a refactor. Pick\nthe directory and the id once.\n";
+
+// src/agent/templates/project/agents-md.ts
+function agentsMd(spec2, n3) {
+  const browserToo = spec2.capabilities.includes("browser") ? ", and neither is Browser Rendering" : "";
+  const where = mdTable(
+    ["You are changing…", "It goes in"],
+    [
+      ["what the agent _is_ — its identity, its rules", `\`${n3.dir}/soul.ts\``],
+      ["which capabilities it has", `\`${n3.dir}/plugins.ts\``],
+      [
+        "the model, when the conversation compacts, or how long a step waits",
+        `\`${n3.dir}/tuning.ts\``
+      ],
+      ["what it advertises to a gatekeeper", `\`${n3.dir}/manifest.ts\``],
+      ["the steps its task runs", `\`${n3.dir}/workflow.ts\``],
+      ...spec2.subAgent ? [["its sub-agent — spec, soul, model", `\`${n3.dir}/children.ts\``]] : [],
+      ["what a person reads when a task ends badly", "`src/copy.ts`"],
+      [
+        "what the model is told about a domain",
+        "the plugin that owns that domain"
+      ],
+      [
+        "cancellation, recovery, idempotency, delegation",
+        "**`@dynamicagents/core`** — not here"
+      ],
+      [
+        "the Durable Object a capability runs in",
+        "**`@dynamicagents/plugins`** — not here"
+      ]
+    ]
+  );
+  const tests = mdTable(
+    ["file", "what it pins"],
+    [
+      [
+        "`test/turn.spec.ts`",
+        "The whole A2A lifecycle on a scripted model: a gatekeeper-signed request reaches the host, the pipeline runs the agent, and the push callback says what happened."
+      ],
+      [
+        "`test/edge.spec.ts`",
+        "The zero-trust edge with no model involved: the signed card, the JWKS, and what an unauthenticated or wrongly-scoped call gets."
+      ],
+      [
+        "`test/soul.spec.ts`",
+        "That the soul stays within its rules as it is rewritten."
+      ],
+      [
+        "`test/manifest.spec.ts`",
+        "That the card advertises what the agent actually has."
+      ],
+      [
+        "`test/tuning.spec.ts`",
+        "That the numbers are consistent with each other."
+      ],
+      [
+        "`test/plugins.spec.ts`",
+        "That every installed plugin's bindings exist in `wrangler.jsonc`."
+      ]
+    ]
+  );
+  const merge = mdTable(
+    ["file", "what to do"],
+    mergeSteps(n3.dir).map((step) => [`\`${step.path}\``, step.what])
+  );
+  return render(AGENTS_md_default, {
+    tokens: {
+      TENANT: spec2.tenant,
+      NAME: spec2.name,
+      BROWSER_TOO: browserToo,
+      // Every table keeps its helper: `mdTable` pads each cell to its
+      // column's width, so the layout depends on the tenant id in it — and
+      // `where` and `merge` vary in their *number of rows* besides.
+      WHERE_TABLE: where,
+      TESTS_TABLE: tests,
+      MERGE_TABLE: merge,
+      MERGE_CAVEAT
+    }
+  });
+}
+
+// src/agent/templates/project/eslint.config.js.tpl
+var eslint_config_js_default = 'import tseslint from "typescript-eslint";\nimport da from "@dynamicagents/core/eslint";\n\nconst LINTED_FILES = ["src/**/*.ts", "test/**/*.ts"];\n\nexport default tseslint.config(\n  {\n    extends: [...tseslint.configs.recommended],\n    files: LINTED_FILES,\n    rules: {\n      "@typescript-eslint/no-explicit-any": "error",\n      "no-unused-expressions": "off",\n      // The Agents SDK\'s `this.sql`…`` statements are tagged templates run for\n      // their side effect; keep the rule for everything else.\n      "@typescript-eslint/no-unused-expressions": [\n        "error",\n        { allowTaggedTemplates: true }\n      ],\n      "@typescript-eslint/no-unused-vars": [\n        "error",\n        {\n          argsIgnorePattern: "^_",\n          varsIgnorePattern: "^_",\n          caughtErrorsIgnorePattern: "^_"\n        }\n      ]\n    }\n  },\n  {\n    // Type-aware pass — enables @deprecated detection without switching the\n    // whole config to recommendedTypeChecked and its stricter rule set.\n    files: LINTED_FILES,\n    plugins: { "@typescript-eslint": tseslint.plugin, da },\n    languageOptions: {\n      parser: tseslint.parser,\n      parserOptions: {\n        projectService: true,\n        tsconfigRootDir: import.meta.dirname\n      }\n    },\n    rules: {\n      "@typescript-eslint/no-deprecated": "error",\n      // Covers the object-literal keys `no-deprecated` structurally cannot see —\n      // every `generateText({ system: … })`-style options bag.\n      "da/no-deprecated-object-properties": "error"\n    }\n  },\n  {\n    ignores: [\n      "worker-configuration.d.ts",\n      "node_modules/",\n      ".wrangler/",\n      "dist/"\n    ]\n  }\n);\n';
+
+// src/agent/templates/project/gitignore.tpl
+var gitignore_default = "node_modules/\ndist/\n.wrangler/\n*.tsbuildinfo\n*.log\n\n# Secrets. `.env.example` is the one file here that is committed.\n.env\n.env.*\n!.env.example\n\n# Written by `npm run types` from wrangler.jsonc.\nworker-configuration.d.ts\n\n.DS_Store\n";
+
+// src/agent/templates/project/prettierignore.tpl
+var prettierignore_default = "node_modules/\ndist/\n.wrangler/\n\n# Written by `npm run types`.\nworker-configuration.d.ts\n";
+
+// src/agent/templates/project/test-tsconfig.json.tpl
+var test_tsconfig_json_default = '{\n  "extends": "../tsconfig.json",\n  "compilerOptions": {\n    "types": [\n      "../worker-configuration.d.ts",\n      "node",\n      "@cloudflare/vitest-plugin/types"\n    ]\n  },\n  "include": ["./**/*.ts"]\n}\n';
+
+// src/agent/templates/project/tsconfig.json.tpl
+var tsconfig_json_default = '{\n  "compilerOptions": {\n    "target": "ES2022",\n    "module": "ESNext",\n    "moduleResolution": "Bundler",\n    "lib": ["ES2022"],\n    "types": ["./worker-configuration.d.ts", "node"],\n    "strict": true,\n    "noEmit": true,\n    "skipLibCheck": true,\n    "esModuleInterop": true,\n    "verbatimModuleSyntax": true,\n    "isolatedModules": true,\n    "paths": {\n      "@/*": ["./src/*"]\n    }\n  },\n  "include": ["src/**/*.ts"]\n}\n';
+
+// src/agent/templates/project/dotfiles.ts
+var tsconfigJson = tsconfig_json_default;
+var testTsconfigJson = test_tsconfig_json_default;
+var prettierrc = jsonFile({ trailingComma: "none" });
+var nvmrc = `${NODE_VERSION}
+`;
+var prettierignore = prettierignore_default;
+var gitignore = gitignore_default;
+var eslintConfigJs = eslint_config_js_default;
+
+// src/agent/templates/project/env.example.tpl
+var env_example_default = '# Copy to `.env` for local `wrangler dev`. In production set each as a secret:\n# `wrangler secret put <NAME>`, or `wrangler deploy --secrets-file .env`.\n#\n# Wrangler loads `.env`, then `.env.local`, then — when you pass `--env <name>` —\n# `.env.<name>` and `.env.<name>.local`, each overriding the last. So a staging\n# deployment is `.env.staging`, not an edit to wrangler.jsonc. Everything but\n# this example file is gitignored.\n#\n# One caveat: if a `.dev.vars` file exists it wins outright and none of the\n# above is read. This project uses `.env`; keep a single file so there is never\n# a question which one is live.\n\n# One Ed25519 private JWK, on a single line, signing the card this Worker serves\n# and every push-notification callback JWT. It MUST include a `kid`. Generate\n# one with `npm run keygen`.\n#\n# Only the matching PUBLIC key is ever exposed, at /.well-known/jwks.json — the\n# private half never leaves the Worker, and is never configured anywhere else:\n# the Worker derives the public half from it.\nA2A_SIGNING_KEY=\n\n# JSON array of the gatekeeper origins this deployment accepts calls from, e.g.\n# ["https://gatekeeper.example.com"]. A property of this deployment, like the\n# key. Not a traditional secret, but kept out of wrangler.jsonc so it can differ\n# per environment with no code change.\nGATEKEEPER_ORIGINS=\n\n# There is no credential here for the agent\'s own model, deliberately.\n#\n# `$TENANT` runs its model on Workers AI through the `AI` binding, which\n# Cloudflare authenticates for the Worker. There is no key to store and none to\n# rotate, and no AI Gateway token either: the binding does not send one. A\n# gateway 401 means Authenticated Gateway is switched on for the `default` AI\n# Gateway every call goes through — switch it off.\n';
+
+// src/agent/templates/project/env-example.ts
+var envExample = (spec2) => render(env_example_default, { tokens: { TENANT: spec2.tenant } });
+
+// src/agent/templates/project/host-manifest.ts.tpl
+var host_manifest_ts_default = 'import type { AgentManifest } from "@dynamicagents/core/a2a";\n\n/**\n * The **stub** card served at `/.well-known/agent-card.json`.\n *\n * It describes the deployment, not the agent. The agent is a tenant of this\n * endpoint, so this card exists to be the single conformant, signed AgentCard at\n * the URI RFC 8615 and A2A\'s IANA registration reserve — advertising where to\n * call, which protocol, and that real cards are reachable through\n * `GetExtendedAgentCard`.\n *\n * It cannot list tenants as interfaces: a card carries one interface entry and\n * spec §8.3.2 has clients take the first, so one entry per tenant would just\n * make every client address whichever came first. They go in `description` for a\n * human reading the deploy in a browser, and are registered out of band.\n *\n * **The description must name every mounted tenant.** It is the only place this\n * card says what is here, so a tenant missing from it is a tenant an operator\n * reading the deploy has no way to discover. Mounting a second agent in\n * `src/index.ts` means naming it here too.\n *\n * `skills` is empty for the same reason: the skills belong to the tenants, and a\n * client that picked one from here would have no way to act on it.\n */\nexport const hostManifest: AgentManifest = {\n  // $block CARD_IDENTITY\n  version: "0.1.0",\n  // `extensions` is a required (repeated) protobuf field in v1.0, and this\n  // deployment declares no protocol extensions, so it stays empty.\n  // `extendedAgentCard` is set by core, which owns that contract.\n  capabilities: { streaming: false, pushNotifications: true, extensions: [] },\n  defaultInputModes: ["text/plain"],\n  defaultOutputModes: ["text/plain"],\n  skills: []\n};\n';
+
+// src/agent/templates/project/host-manifest.ts
+function hostManifestTs(spec2) {
+  const description2 = `Hosts a Dynamic Agent behind one A2A endpoint. This card describes the deployment rather than the agent — call GetExtendedAgentCard with a tenant id to fetch an agent's own card. Tenants: \`${spec2.tenant}\` (${spec2.description.replace(/\.$/, "")}).`;
+  return render(host_manifest_ts_default, {
+    tokens: {
+      // A block, and with its trailing comma: this description is long enough
+      // to break after the colon in every project, and `stringProp` is what
+      // knows where. See `../agent/manifest.ts` on the comma.
+      CARD_IDENTITY: `${[
+        stringProp("name", spec2.tenant),
+        stringProp("description", description2)
+      ].join(",\n")},`
+    }
+  });
+}
+
+// src/agent/templates/dependencies.ts
+var sorted = (map) => Object.fromEntries(
+  Object.entries(map).sort(([a2], [b]) => a2.localeCompare(b))
+);
+function dependenciesFor(spec2) {
+  const deps = {
+    "@dynamicagents/core": TRAIN.core,
+    "@cloudflare/computer": RUNTIME["@cloudflare/computer"],
+    "@cloudflare/think": RUNTIME["@cloudflare/think"],
+    agents: RUNTIME.agents,
+    ai: RUNTIME.ai,
+    "workers-ai-provider": RUNTIME["workers-ai-provider"],
+    "@a2a-js/sdk": RUNTIME["@a2a-js/sdk"]
+  };
+  if (spec2.subAgent) deps.zod = RUNTIME.zod;
+  if (spec2.capabilities.length > 0) {
+    deps["@dynamicagents/plugins"] = TRAIN.plugins;
+  }
+  return sorted(deps);
+}
+var devDependenciesFor = () => sorted({ ...TOOLCHAIN });
+
+// src/agent/templates/project/package-json.ts
+var packageJson = (spec2) => jsonFile({
+  name: spec2.tenant,
+  version: "0.1.0",
+  private: true,
+  description: spec2.description,
+  type: "module",
+  scripts: {
+    dev: "wrangler dev",
+    deploy: "wrangler deploy",
+    types: "wrangler types",
+    keygen: "da-keys",
+    format: "prettier --write .",
+    lint: "eslint .",
+    check: "wrangler types --check && prettier --check . && eslint . && tsc && tsc -p test/tsconfig.json",
+    test: "vitest run",
+    "test:watch": "vitest"
+  },
+  dependencies: dependenciesFor(spec2),
+  devDependencies: devDependenciesFor(),
+  engines: { node: NODE_ENGINE }
+});
+
+// src/agent/templates/project/README.md.tpl
+var README_md_default = "# $NAME\n\n$DESCRIPTION\n\nA Dynamic Agent on Cloudflare Workers: zero-trust A2A, a durable task\nlifecycle, and one continuous, self-compacting conversation per caller. Built on\n[`@dynamicagents/core`](https://github.com/dynamicagents/core), scaffolded with\n`npm create dynamicagents`.\n\n- **One Worker, one agent.** This deployment serves exactly this agent, as the\n  A2A tenant `$TENANT`.$DELEGATION$CAPABILITIES- **Its own everything.** Its own wrangler config, its own bindings, its own\n  signing key. Nothing it does can affect another agent.\n\n> **A paid Cloudflare Workers plan is required.** The model this agent runs on is\n> not served on the free tier$BROWSER_NOTE. There is no free-tier\n> configuration of this project.\n\n---\n\n## Quick start\n\n```bash\nnpm run keygen     # one Ed25519 key for this deployment\n```\n\nPut the private JWK in `.env` as `A2A_SIGNING_KEY`, and the gatekeeper origins\nyou accept calls from in `GATEKEEPER_ORIGINS`. [`.env.example`](.env.example)\nsays what each one is.\n\n```bash\nnpm run check      # types, format, lint, typecheck\nnpm test           # the suite, in real workerd\nnpm run dev        # local\n```\n\nTo ship, set the same secrets with `wrangler secret put` (or push the file with\n`npx wrangler deploy --secrets-file .env`) and:\n\n```bash\nnpm run deploy\n```\n\nThen register the agent with your gatekeeper:\n\n$REGISTRATION\n\nA tenant is required on every request — there is no default agent and no\nimplicit routing. The card at `/.well-known/agent-card.json` describes the\ndeployment; the agent's own card comes from `GetExtendedAgentCard` with that\ntenant id.\n\n**Keep one origin.** Core derives the card's URL, its `jku` and the token\naudience from the origin a request arrives on, so a second origin advertises a\nsecond audience and a token minted for one will not verify against the other.\n`wrangler.jsonc` says what to change when you move to a domain of your own.\n\n---\n\n## The files you will actually edit\n\n$FILES_TABLE\n\n[`AGENTS.md`](AGENTS.md) is the rest: where everything goes, what the tests\npin, the two invariants worth knowing, and how to bring a second agent into this\nWorker later.\n\n## License\n\nYours.\n";
+
+// src/agent/templates/project/readme.ts
+function readmeMd(spec2, n3) {
+  const browser = spec2.capabilities.includes("browser");
+  const delegation = spec2.subAgent ? "\n- **Delegates.** Self-contained pieces of a request go to a sub-agent and come back composed into one answer.\n" : "";
+  const capabilities2 = browser ? "\n- **Reads web pages**, through Browser Rendering.\n" : "";
+  const registration = mdTable(
+    ["endpoint", "tenant id"],
+    [["`https://<your-worker>/a2a`", `\`${spec2.tenant}\``]]
+  );
+  const files = mdTable(
+    ["file", "what it decides"],
+    [
+      [
+        `[\`${n3.dir}/soul.ts\`](${n3.dir}/soul.ts)`,
+        "Who the agent is. **Start here** — it was seeded from one line."
+      ],
+      [
+        `[\`${n3.dir}/plugins.ts\`](${n3.dir}/plugins.ts)`,
+        "What it can do. One line per capability."
+      ],
+      [
+        `[\`${n3.dir}/tuning.ts\`](${n3.dir}/tuning.ts)`,
+        `Its model, when the conversation compacts, and how long a step waits for an event that never arrived. Every model id is at ${MODELS_URL}`
+      ],
+      [
+        `[\`${n3.dir}/manifest.ts\`](${n3.dir}/manifest.ts)`,
+        "What it advertises to a gatekeeper."
+      ],
+      [
+        `[\`${n3.dir}/workflow.ts\`](${n3.dir}/workflow.ts)`,
+        "The steps a task runs. One today."
+      ],
+      [
+        "[`src/copy.ts`](src/copy.ts)",
+        "What a person reads when a task ends badly."
+      ]
+    ]
+  );
+  return render(README_md_default, {
+    tokens: {
+      NAME: spec2.name,
+      DESCRIPTION: spec2.description,
+      TENANT: spec2.tenant,
+      DELEGATION: delegation,
+      CAPABILITIES: capabilities2,
+      BROWSER_NOTE: browser ? ", and neither is Browser Rendering" : "",
+      // Both tables keep their helper: `mdTable` pads every cell to its
+      // column's width, so the layout depends on the tenant id in it.
+      REGISTRATION: registration,
+      FILES_TABLE: files
+    }
+  });
+}
+
+// src/agent/templates/project/copy.ts.tpl
+var copy_ts_default = 'import {\n  ASK_USER_TOOL_NAME,\n  CHECK_BACK_TOOL_NAME\n} from "@dynamicagents/core/agent";\nimport type { A2ACopy } from "@dynamicagents/core/task";\n\n/**\n * The words this Worker\'s agents say that core refuses to write: what a person\n * reads when a task ends without an answer, and the parts of a soul or a job\'s\n * first message that are not about one agent\'s domain.\n *\n * At the top level rather than inside the agent\'s directory because nothing\n * here names an agent — which is also what lets a second agent share it\n * unchanged.\n */\n\n/** What a person reads when a task ends with no answer to give them. */\nexport const copy: A2ACopy = {\n  /** A task whose steps failed. The diagnostic is logged, not shown. */\n  failed: "Sorry — something went wrong handling that request.",\n  /** A task that finished with nothing to say. */\n  emptyReply:\n    "I finished, but had nothing to report. Ask again if you expected an answer."\n};\n\n/**\n * When to ask the person, for every soul. `ask_user`\'s own description says\n * what the call does; this says when it is worth a person\'s attention.\n */\nexport const ASK_GUIDANCE = `## When only the person can tell you\n\n\\`${ASK_USER_TOOL_NAME}\\` puts your questions to the person who made this request and stops. Ask when you cannot go on well without something only they can give you: a choice between options that would each change what you do, a fact that is nowhere you can look, or a go-ahead for something they may not want. Do not ask what you can look up, work out, or reasonably assume — say what you assumed instead.`;\n\n/**\n * When to wait, for an agent that has `check_back`. Not in this agent\'s soul\n * yet: add it to `SOUL` when there is something it has to wait on. The two\n * failures to write against are waiting *instead of working*, where each pause\n * reads as progress, and answering *instead of waiting*, where the reply calls\n * the work done pending a review nobody has read.\n */\nexport const WAIT_GUIDANCE = `## When you are waiting on something\n\n\\`${CHECK_BACK_TOOL_NAME}\\` ends this turn and wakes you on the same request later, with the reason you gave. Use it for something you cannot hurry and can look at again — a review being written, a build, a deploy. **When you wake, check the thing you named before deciding anything else.** Never use it to pause between steps you could take now; if you are waiting on a person rather than an event, that is \\`${ASK_USER_TOOL_NAME}\\`.`;\n\n/**\n * Ahead of a job\'s second attempt. A pipeline runs a failed step once more, in\n * the same conversation, so without this the model meets its request twice.\n */\nexport const RETRY_BRIEF =\n  "Your previous attempt at this stopped before it finished. Its work is kept: what it said and did is above. Look at what it left first, and carry on from there rather than starting again.";\n';
+
+// src/agent/templates/project/model.ts.tpl
+var model_ts_default = 'import type { LanguageModel } from "ai";\nimport {\n  gatewayLogFields,\n  workersAIModel,\n  type GatewayCorrelation\n} from "@dynamicagents/core/model";\n\n/**\n * The one model an agent or a sub-agent runs, as its `getModel()` returns it.\n *\n * One function for every class in this project, because what each call tells AI\n * Gateway about itself has to be spelled the same way everywhere or a log filter\n * on it silently misses the classes that spelled it differently.\n *\n * `sessionAffinity` is the object\'s name: every call an object makes re-sends\n * one history, so anything finer routes a call away from the prefix it is about\n * to re-send.\n *\n * There is no model credential anywhere in this project. Workers AI is reached\n * through the `AI` binding, which Cloudflare authenticates for the Worker.\n */\nexport function agentModel(\n  env: Env,\n  model: { modelId: string; name: string },\n  correlation: GatewayCorrelation\n): LanguageModel {\n  return workersAIModel(env, {\n    modelId: model.modelId,\n    sessionAffinity: model.name,\n    ...gatewayLogFields(correlation)\n  });\n}\n\n/**\n * The task a sub-agent\'s turn is for. Core stamps it on the dispatch\'s\n * `turnMetadata`, where Think keeps it for a recovered turn too.\n */\nexport function turnTask(metadata: unknown): string | undefined {\n  const taskId = (metadata as { taskId?: unknown } | undefined)?.taskId;\n  return typeof taskId === "string" ? taskId : undefined;\n}\n';
+
+// src/agent/templates/project/shared.ts
+var copyTs = copy_ts_default;
+var modelTs = model_ts_default;
+
+// src/agent/templates/project/vitest.config.ts.tpl
+var vitest_config_ts_default = 'import { defineConfig } from "vitest/config";\nimport { cloudflareTest } from "@cloudflare/vitest-plugin";\nimport path from "node:path";\n// The realm-neutral slice, deliberately. This file runs in **Node**, and the\n// `/testing` barrel pulls in `cloudflare:test`, which fails at load before a\n// single test runs.\nimport {\n  GATEKEEPER_ORIGIN,\n  TEST_AGENT_PRIVATE_JWK\n} from "@dynamicagents/core/testing/fixtures";\n\n/**\n * The whole suite runs in the Workers runtime (workerd via miniflare) through\n * one `cloudflareTest()` pool.\n *\n * The pool reads `wrangler.jsonc` directly — the compatibility settings, the AI\n * binding, the Durable Objects and their SQLite migration — so this config\n * cannot drift from it. Its `main` is `test/worker.ts`, which is this Worker\n * plus the agent on a scripted model: Workers AI has no local execution mode,\n * so a real model cannot finish a turn here.\n */\n\n// Test defaults for the secrets `wrangler.jsonc` requires. Real env vars — from\n// CI or the shell — take precedence through `??=`. The pool sources\n// `secrets.required` from `process.env` into the worker `env`.\nprocess.env.A2A_SIGNING_KEY ??= JSON.stringify(TEST_AGENT_PRIVATE_JWK);\nprocess.env.GATEKEEPER_ORIGINS ??= JSON.stringify([GATEKEEPER_ORIGIN]);\n\nexport default defineConfig({\n  resolve: {\n    alias: { "@": path.resolve(import.meta.dirname, "./src") }\n  },\n  plugins: [\n    cloudflareTest({\n      wrangler: { configPath: "./wrangler.jsonc" },\n      main: "./test/worker.ts",\n      // Required, not just the default. Workers AI has no local execution mode\n      // — miniflare always proxies `AI` through a remote-connection worker —\n      // and leaving this unset makes the pool open that connection per test\n      // file, for a binding no spec here calls. `false` avoids it entirely.\n      remoteBindings: false,\n      miniflare: {\n        // Test-only Durable Object bindings: the scripted classes in\n        // `test/worker.ts`, which `wrangler.jsonc` knows nothing about.\n        // $when subAgent\n        //\n        // In production a sub-agent needs **no** binding and no\n        // `new_sqlite_classes` entry — its storage is a facet created beneath\n        // the bound parent agent — but the pool only treats *bound* classes as\n        // Durable Object classes, so without one here the parent cannot create\n        // it.\n        // $end\n        durableObjects: {\n          // $block DURABLE_OBJECTS\n        },\n        // The scripted pipeline, beside the real one `wrangler.jsonc` binds.\n        workflows: {\n          TEST_$WORKFLOW_BINDING: {\n            name: "test-$WORKFLOW_NAME",\n            className: "$TEST_WORKFLOW_CLASS"\n          }\n        }\n      }\n    })\n  ],\n  test: {\n    include: ["test/**/*.spec.ts"],\n    // A task runs in a Workflow and on its agent\'s alarms, so a lifecycle spec\n    // waits on real scheduling rather than on a promise.\n    testTimeout: 60_000,\n    hookTimeout: 60_000\n  }\n});\n';
+
+// src/agent/templates/project/vitest-config.ts
+function vitestConfigTs(spec2, n3) {
+  const T = `Test${n3.pascal}`;
+  const durableObject = (binding, className) => `          ${binding}: {
+            className: "${className}",
+            useSQLite: true
+          }`;
+  return render(vitest_config_ts_default, {
+    when: { subAgent: spec2.subAgent },
+    tokens: {
+      WORKFLOW_BINDING: n3.workflowBinding,
+      WORKFLOW_NAME: n3.workflowName,
+      TEST_WORKFLOW_CLASS: `${T}Workflow`,
+      // Two bindings or three: the count is what the sub-agent changes, and a
+      // list whose length is computed is a block rather than a region, because
+      // which element is last decides where the commas go.
+      DURABLE_OBJECTS: [
+        durableObject(`TEST_${n3.screaming}_HOST`, `${T}Host`),
+        durableObject(`TEST_${n3.screaming}_AGENT`, `${T}Agent`),
+        ...spec2.subAgent ? [durableObject(`TEST_${n3.screaming}_CHILD`, `${T}Child`)] : []
+      ].join(",\n")
+    }
+  });
+}
+
+// src/agent/templates/project/index.ts.tpl
+var index_ts_default = 'import { createA2AWorker } from "@dynamicagents/core/worker";\nimport { Artifacts, handleArtifactRoute } from "@dynamicagents/core/artifacts";\n\nimport { hostManifest } from "./host-manifest";\nimport { $CAMEL } from "./agents/$TENANT/definition";\n\n// Durable Objects and Workflows must be exported from the Worker entry so the\n// runtime can resolve them by class name: the task host, the pipeline it runs\n// each task as, and the step agent the pipeline\'s steps run on.\n// $when subAgent\n//\n// The sub-agent class is a **facet**: it is created beneath its agent, so it\n// needs no wrangler binding and no `new_sqlite_classes` entry — only this\n// export, so `ctx.exports` can resolve it by class name.\n// $end\nexport { $HOST_CLASS } from "./agents/$TENANT/host";\nexport { $WORKFLOW_CLASS } from "./agents/$TENANT/workflow";\nexport { $AGENT_CLASS } from "./agents/$TENANT/agent";\n// $when subAgent\nexport { $CHILD_CLASS } from "./agents/$TENANT/children";\n// $end\n\n// Core\'s own class, re-exported unmodified — there is nothing here to subclass,\n// and a Durable Object namespace is keyed by class name, so this export is what\n// the `ARTIFACTS` binding resolves to. Why it is required rather than optional\n// sits beside that binding in wrangler.jsonc.\nexport { Artifacts };\n\n/**\n * One Worker, one agent, addressed by A2A `tenant`.\n *\n * ```\n * /.well-known/agent-card.json   the stub card for this deployment\n * /.well-known/jwks.json         the public key, verifying every card it signs\n * /a2a                           the agent, picked by params.tenant\n * ```\n *\n * A tenant is required on every request: there is no default agent and no\n * implicit routing, and that holds with one agent exactly as it would with\n * twenty. `AgentInterface.tenant` is the A2A mechanism for it, and §8.3.2\n * requires a client to send the value the interface it selected declared.\n *\n * The card is why it is a tenant rather than a path prefix: its location is a\n * **well-known URI**, which RFC 8615 defines per-authority, so this origin\n * serves exactly one card and a gatekeeper pins one key for whatever is behind\n * it. That card is a stub (`./host-manifest.ts`); the agent\'s own comes from\n * `GetExtendedAgentCard`.\n *\n * **A second agent in this Worker** is another directory under `./agents/`,\n * another `defineAgent` imported above, another name in `agents` below, and its\n * own bindings and migration tag — AGENTS.md carries the whole recipe.\n */\nconst a2a = createA2AWorker<Env>({\n  manifest: hostManifest,\n  agents: [$CAMEL]\n});\n\nexport default {\n  /**\n   * The artifact links first, everything else after — and the order is the\n   * requirement, not a preference.\n   *\n   * `handleArtifactRoute` answers `null` for every path it does not claim, so\n   * in front it costs the A2A router nothing and takes nothing from it. Behind\n   * it, `/a/<token>` reaches a router that knows nothing about the prefix, and\n   * what that costs is a link that opens onto the wrong answer rather than a\n   * failure anyone notices. The artifact routes are not A2A and deliberately\n   * sit outside it: no gatekeeper token, no tenant, and the token in the path is\n   * the whole credential.\n   */\n  async fetch(request: Request, env: Env): Promise<Response> {\n    return (await handleArtifactRoute(request, env)) ?? a2a(request, env);\n  }\n} satisfies ExportedHandler<Env>;\n';
+
+// src/agent/templates/project/worker-index.ts
+var indexTs = (spec2, n3) => render(index_ts_default, {
+  when: { subAgent: spec2.subAgent },
+  tokens: {
+    TENANT: spec2.tenant,
+    CAMEL: n3.camel,
+    HOST_CLASS: n3.hostClass,
+    WORKFLOW_CLASS: n3.workflowClass,
+    AGENT_CLASS: n3.agentClass,
+    CHILD_CLASS: n3.childClass
+  }
+});
+
+// src/agent/templates/project/wrangler.jsonc.tpl
+var wrangler_jsonc_default = '/**\n * One Worker, one agent.\n *\n * The agent is a **tenant** of this deployment, routed by `src/index.ts` on the\n * A2A `params.tenant`. That holds with one agent exactly as it would with\n * several, which is what makes adding a second one additive: another directory\n * under `src/agents/`, another block in each list below, and a new migration\n * tag. AGENTS.md carries the recipe.\n *\n * https://developers.cloudflare.com/workers/wrangler/configuration/\n */\n{\n  "$schema": "node_modules/wrangler/config-schema.json",\n  "name": "$TENANT",\n  "main": "src/index.ts",\n  // The date is the runtime: a workerd version *is* a release date, and this is\n  // the one the pinned wrangler version installs. No `compatibility_flags`\n  // beside it, and that is the date\'s doing — `nodejs_compat` is on by default\n  // from 2026-08-04, so declaring it here would say nothing this date does not\n  // already say.\n  "compatibility_date": "$COMPATIBILITY_DATE",\n\n  // **One origin, and keep it.**\n  //\n  // Core derives the card\'s interface URL, its `jku` and the token audience it\n  // verifies from `new URL(request.url).origin`. A second origin therefore\n  // advertises a second audience, and a gatekeeper token minted for one does\n  // not verify against the other — it could only ever serve a card nobody can\n  // call.\n  //\n  // `workers_dev` is on so the first deploy is reachable at a URL you already\n  // have. Moving to a domain of your own is one change: turn it off, declare\n  // the route, deploy, and re-register the tenant with your gatekeeper against\n  // the new origin.\n  //\n  //   "workers_dev": false,\n  //   "routes": [{ "pattern": "agents.example.com", "custom_domain": true }]\n  "workers_dev": true,\n\n  "observability": {\n    "enabled": true\n  },\n\n  // --- required by core -----------------------------------------------------\n\n  // Workers AI backs the agent\'s model, through AI Gateway. There is no model\n  // credential in this project: Cloudflare authenticates this binding for the\n  // Worker. `remote: true` reflects reality — Workers AI has no local execution\n  // mode and always hits remote resources — and suppresses wrangler\'s per-run\n  // warning; the test pool turns it off (vitest.config.ts) so no connection is\n  // opened per test file.\n  "ai": {\n    "binding": "AI",\n    "remote": true\n  },\n  // $when browser\n\n  // `@dynamicagents/plugins/browser`, installed in\n  // $DIR/plugins.ts. Browser Rendering is a paid-plan\n  // binding, and `remote: true` is required for it under `wrangler dev`.\n  "browser": {\n    "binding": "BROWSER",\n    "remote": true\n  },\n  // $end\n\n  // The agent\'s task host, which holds a caller\'s A2A tasks, and the step agent\n  // its pipeline runs on, which holds the SQLite-backed Session — one\n  // continuous history plus writable memory. Both are keyed by the verified\n  // caller, which is what makes a task unreachable from any other caller by\n  // construction.\n  //\n  // A host\'s binding is named as its class: `hostBinding` in\n  // $DIR/host.ts names it, and the pipeline reaches the\n  // host through it.\n  //\n  // $when subAgent\n  // The sub-agent class (`$CHILD_CLASS`) is deliberately absent. It is a\n  // facet created beneath its agent, so it needs no binding and no\n  // `new_sqlite_classes` entry — only its export from src/index.ts. It does\n  // need a test-only binding; see the comment in vitest.config.ts.\n  //\n  // $end\n  // `ARTIFACTS` is **not optional**. Core files every sub-agent note on the\n  // task\'s transcript and posts a link instead of the note, so an agent Durable\n  // Object that starts without this binding throws `ArtifactsNotBoundError`\n  // naming every part of the wiring — the route delegation at the top of\n  // `fetch` in src/index.ts included, since without that one an artifact URL\n  // falls through to routes that know nothing about it. The class is core\'s\n  // own, re-exported unchanged from src/index.ts, and one object serves the\n  // whole deployment: a reader arrives holding a token and nothing else, so the\n  // object it reaches cannot be keyed by task.\n  "durable_objects": {\n    "bindings": [\n      // $block DO_BINDINGS\n    ]\n  },\n\n  // **A tag is applied once, ever.** Anything appended to a tag already\n  // deployed is simply never applied: the class is never created, and the\n  // failure surfaces far from this file — at the first request to the agent, or\n  // at deploy with "New version of script does not export class \'X\' which is\n  // depended on by existing Durable Objects". Always add a new tag.\n  //\n  // Removing a class from the code reclaims nothing on its own either: every\n  // object it created keeps its storage, unreachable and still billed.\n  // `deleted_classes` in a new tag is the line that frees them, and it is\n  // irreversible.\n  "migrations": [\n    {\n      // $block MIGRATION_V1\n    }\n  ],\n\n  // The agent\'s pipeline: every task is an instance, its id the task\'s. The\n  // name is derived from the tenant id rather than from this Worker, so moving\n  // the agent into another Worker never renames it — a rename would abandon\n  // every instance still running under the old name.\n  "workflows": [\n    {\n      "name": "$WORKFLOW_NAME",\n      "binding": "$WORKFLOW_BINDING",\n      "class_name": "$WORKFLOW_CLASS"\n    }\n  ],\n\n  // What an operator fills in; `.env.example` says what each one is. Declared\n  // here because `secrets.required` is what drives type generation and\n  // `wrangler dev`\'s missing-secret warnings — so a name left here and unset is\n  // typed as a definite string that is undefined at runtime.\n  "secrets": {\n    "required": ["A2A_SIGNING_KEY", "GATEKEEPER_ORIGINS"]\n  }\n}\n';
+
+// src/agent/templates/project/wrangler.ts
+function wranglerJsonc(spec2, n3) {
+  const bindings = [
+    [n3.hostClass, n3.hostClass],
+    [n3.agentClass, n3.agentClass],
+    ["Artifacts", "ARTIFACTS"]
+  ].map(
+    ([className, name]) => jsonObject(
+      [
+        ["class_name", className],
+        ["name", name]
+      ],
+      6
+    )
+  ).join(",\n");
+  return render(wrangler_jsonc_default, {
+    when: {
+      browser: spec2.capabilities.includes("browser"),
+      subAgent: spec2.subAgent
+    },
+    tokens: {
+      TENANT: spec2.tenant,
+      COMPATIBILITY_DATE,
+      DIR: n3.dir,
+      CHILD_CLASS: n3.childClass,
+      WORKFLOW_NAME: n3.workflowName,
+      WORKFLOW_BINDING: n3.workflowBinding,
+      WORKFLOW_CLASS: n3.workflowClass,
+      // The two lists that keep their helper, because a long tenant id is what
+      // decides their layout: `jsonObject` goes one property per line and
+      // `jsonArrayProp` one element per line once the line passes the print
+      // width, and `../../formatting.spec.ts` sweeps tenant ids across it.
+      DO_BINDINGS: bindings,
+      /**
+       * The tag is static, and is in here anyway: a `$block` cannot stand
+       * where the property before it would need a trailing comma, because
+       * `trailingComma: "none"` has prettier strip a comma before what it
+       * reads as the last property — and a comment is not one. So the block is
+       * the whole migration rather than its second line.
+       */
+      MIGRATION_V1: [
+        '      "tag": "v1"',
+        jsonArrayProp(
+          "new_sqlite_classes",
+          [n3.hostClass, n3.agentClass, "Artifacts"],
+          6
+        )
+      ].join(",\n")
+    }
+  });
+}
+
+// src/agent/templates/test/edge.spec.ts.tpl
+var edge_spec_ts_default = 'import { describe, expect, it } from "vitest";\nimport { env } from "cloudflare:workers";\nimport { AGENT_CARD_PATH } from "@a2a-js/sdk";\nimport {\n  AGENT_ORIGIN,\n  createAgentHarness,\n  TEST_AGENT_PRIVATE_JWK\n} from "@dynamicagents/core/testing";\nimport worker from "@/index";\n\n/**\n * What the deployment serves before anybody is authenticated, and what it\n * refuses.\n *\n * Every assertion here is about core\'s edge as **this project** configures it:\n * the card it serves is this project\'s `host-manifest.ts`, the key is the one in\n * `.env`, and the tenant is the one `src/index.ts` mounts. No model runs, so\n * this is the spec that still passes when a turn is broken.\n */\n\n/** The one tenant this Worker mounts, and the name on its card. */\nconst TENANT = "$TENANT";\nconst NAME = $NAME_LITERAL;\n\nconst harness = createAgentHarness({ worker, env, tenant: TENANT });\n\nconst get = (path: string) =>\n  worker.fetch(new Request(`${AGENT_ORIGIN}${path}`), env);\n\nconst sendMessage = (tenant: string) => ({\n  jsonrpc: "2.0",\n  id: 1,\n  method: "SendMessage",\n  params: { tenant }\n});\n\ndescribe("discovery", () => {\n  it("serves one signed stub card at the well-known path", async () => {\n    // One card per origin, because a well-known URI is per-authority (RFC 8615)\n    // and A2A registered this path with IANA. The agent\'s own card comes from\n    // `GetExtendedAgentCard` below.\n    const res = await get(`/${AGENT_CARD_PATH}`);\n    expect(res.status).toBe(200);\n\n    const card = await res.json<{\n      name: string;\n      capabilities: { extendedAgentCard: boolean };\n      supportedInterfaces: { url: string; tenant: string }[];\n      signatures: { protected: string }[];\n    }>();\n\n    // It describes the deployment, and names no tenant.\n    expect(card.supportedInterfaces[0]!.tenant ?? "").toBe("");\n    expect(card.supportedInterfaces[0]!.url).toBe(`${AGENT_ORIGIN}/a2a`);\n    expect(card.capabilities.extendedAgentCard).toBe(true);\n\n    // Signed by this deployment\'s key, and pointing a verifier at where the\n    // public half is served.\n    const header = JSON.parse(\n      atob(card.signatures[0]!.protected.replace(/-/g, "+").replace(/_/g, "/"))\n    ) as { jku: string; alg: string };\n    expect(header.jku).toBe(`${AGENT_ORIGIN}/.well-known/jwks.json`);\n    expect(header.alg).toBe("EdDSA");\n  });\n\n  it("serves the public half of the signing key, and only that", async () => {\n    const res = await get("/.well-known/jwks.json");\n    expect(res.status).toBe(200);\n\n    const body = await res.json<{ keys: Record<string, unknown>[] }>();\n    expect(body.keys[0]!.kid).toBe(TEST_AGENT_PRIVATE_JWK.kid);\n    // The private half must never be served.\n    expect(body.keys[0]!).not.toHaveProperty("d");\n  });\n\n  it("returns the agent\'s own card for its tenant", async () => {\n    using _ = harness.interceptGatekeeper();\n\n    const res = await harness.rpc({\n      jsonrpc: "2.0",\n      id: 1,\n      method: "GetExtendedAgentCard",\n      params: { tenant: TENANT }\n    });\n    const body = await res.json<{\n      result: { name: string; supportedInterfaces: { tenant: string }[] };\n    }>();\n\n    expect(body.result.name).toBe(NAME);\n    expect(body.result.supportedInterfaces[0]!.tenant).toBe(TENANT);\n  });\n});\n\ndescribe("what it refuses", () => {\n  it("refuses an unauthenticated call", async () => {\n    const res = await worker.fetch(\n      new Request(`${AGENT_ORIGIN}/a2a`, {\n        method: "POST",\n        headers: { "content-type": "application/json" },\n        body: JSON.stringify(sendMessage(TENANT))\n      }),\n      env\n    );\n    expect(res.status).toBe(401);\n  });\n\n  it("refuses a token minted for another tenant", async () => {\n    // Every agent behind one gatekeeper shares an audience, so the tenant claim\n    // is what separates them — and this is the assertion that says so. It holds\n    // with one agent mounted exactly as it would with several.\n    using _ = harness.interceptGatekeeper();\n\n    const res = await harness.rpc(sendMessage(TENANT), {\n      token: await harness.token({ tenant: "somebody-else" })\n    });\n    expect(res.status).toBe(401);\n  });\n});\n';
+
+// src/agent/templates/test/edge-spec.ts
+var edgeSpec = (spec2) => render(edge_spec_ts_default, {
+  tokens: {
+    TENANT: spec2.tenant,
+    // `JSON.stringify` rather than `quoted()`, which is what this template
+    // has always written: the two differ only for a name holding a double
+    // quote, and changing it would change what a user receives.
+    NAME_LITERAL: JSON.stringify(spec2.name)
+  }
+});
+
+// src/agent/templates/test/worker.ts.tpl
+var worker_ts_default = 'import type { ThinkModel } from "@cloudflare/think";\nimport type { WorkflowEvent, WorkflowStep } from "cloudflare:workers";\nimport { handleArtifactRoute } from "@dynamicagents/core/artifacts";\n// $when subAgent\nimport type { SubAgentClass } from "@dynamicagents/core/subagent";\n// $end\nimport {\n  // $when subAgent\n  call,\n  // $end\n  scriptedModel,\n  type MockStep,\n  type ModelTurnView\n} from "@dynamicagents/core/testing";\nimport { createA2AWorker, defineAgent } from "@dynamicagents/core/worker";\nimport type { TaskParams } from "@dynamicagents/core/workflow";\nimport { RETRY_BRIEF } from "@/copy";\nimport { hostManifest } from "@/host-manifest";\nimport { $AGENT_CLASS } from "@/agents/$TENANT/agent";\n// $when subAgent\nimport { $CHILD_CLASS } from "@/agents/$TENANT/children";\n// $end\nimport { $HOST_CLASS } from "@/agents/$TENANT/host";\nimport { manifest } from "@/agents/$TENANT/manifest";\nimport { $WORKFLOW_CLASS } from "@/agents/$TENANT/workflow";\n\n/**\n * The Worker the suite runs: this project\'s own, plus the agent on a scripted\n * model.\n *\n * Workers AI has no local execution mode, so the real `getModel()` cannot\n * finish a turn here. Each `Test*` class below is the real one with only its\n * model swapped$SUBAGENT_NOTE, behind the real host and the real pipeline\n * pointed at it, so a spec drives the agent\'s actual plugins, soul, card and\n * lifecycle through core\'s A2A edge. They are bound for tests only, in\n * `vitest.config.ts`.\n *\n * Every production class is re-exported, because the runtime resolves a Durable\n * Object by class name and the pool loads this module in place of\n * `src/index.ts`.\n */\n\nexport * from "@/index";\n\nexport interface TestEnv extends Env {\n  $TEST_HOST_BINDING: DurableObjectNamespace<$TEST_HOST_CLASS>;\n  $TEST_AGENT_BINDING: DurableObjectNamespace<$TEST_AGENT_CLASS>;\n  $TEST_WORKFLOW_BINDING: Workflow<TaskParams>;\n}\n\n/** `prefix:rest` → `rest`. */\nfunction after(text: string, prefix: string): string | undefined {\n  return text.startsWith(prefix) ? text.slice(prefix.length) : undefined;\n}\n\n// $when subAgent\n/** The text of the most recent tool result, as the model was shown it. */\nfunction lastToolOutput(view: ModelTurnView): string {\n  for (let i = view.prompt.length - 1; i >= 0; i--) {\n    const message = view.prompt[i]!;\n    if (message.role !== "tool") continue;\n    const part = message.content.find((p) => p.type === "tool-result") as\n      { output?: { value: unknown } } | undefined;\n    const value = part?.output?.value;\n    return typeof value === "string" ? value : JSON.stringify(value);\n  }\n  return "";\n}\n\n// $end\n/**\n * The agent\'s script, keyed on the message that started the turn rather than on\n * a queue: a retry, a follow-up turn and a recovered one all consume steps, and\n * which call comes next is not something a spec controls.\n *\n * A retry arrives with `RETRY_BRIEF` in front of the original text, which is\n * how `flaky` tells its second attempt from its first.\n */\nfunction script(view: ModelTurnView): MockStep {\n  const retry = view.lastUserText.startsWith(RETRY_BRIEF);\n  const text = retry\n    ? view.lastUserText.slice(RETRY_BRIEF.length).trimStart()\n    : view.lastUserText;\n\n  // Fails every attempt, so the task settles failed in this project\'s words.\n  if (text === "boom") return { error: "told to fail" };\n  // Fails the first attempt only: the retry\'s brief is what recovers it.\n  if (text === "flaky") {\n    return retry ? { text: "recovered" } : { error: "told to fail once" };\n  }\n\n  // $when subAgent\n  // `delegate:<task>` hands the task to the sub-agent and then answers with\n  // what it reported, which is what proves the result came back.\n  const delegate = after(text, "delegate:");\n  if (delegate !== undefined) {\n    return view.answered\n      ? { text: lastToolOutput(view) }\n      : call("general", { task: delegate }, "Delegating.");\n  }\n\n  // $end\n  return { text: after(text, "echo:") ?? text };\n}\n\nexport class $TEST_AGENT_CLASS extends $AGENT_CLASS {\n  override getModel(): ThinkModel {\n    return scriptedModel(script);\n  }\n  // $when subAgent\n\n  override getSubAgents(): SubAgentClass[] {\n    return [$TEST_CHILD_CLASS];\n  }\n  // $end\n}\n\n// $when subAgent\n/** The sub-agent, answering from a script of its own. */\nexport class $TEST_CHILD_CLASS extends $CHILD_CLASS {\n  static override spec = $CHILD_CLASS.spec;\n\n  override getModel(): ThinkModel {\n    return scriptedModel((view) => ({\n      text: `child did: ${view.lastUserText}`\n    }));\n  }\n}\n\n// $end\n/** The real host, pointed at the scripted pipeline. */\nexport class $TEST_HOST_CLASS extends $HOST_CLASS {\n  // $block HOST_BINDINGS\n}\n\n/**\n * The real pipeline, on the scripted agent. It declares `run()`, as every\n * pipeline must.\n */\nexport class $TEST_WORKFLOW_CLASS extends $WORKFLOW_CLASS {\n  // $block STEP_AGENT\n  override run(event: WorkflowEvent<TaskParams>, step: WorkflowStep) {\n    return super.run(event, step);\n  }\n}\n\nconst a2a = createA2AWorker<TestEnv>({\n  manifest: hostManifest,\n  agents: [\n    defineAgent({\n      tenant: "$TENANT",\n      manifest,\n      agent: (env: TestEnv) => env.$TEST_HOST_BINDING\n    })\n  ]\n});\n\nexport default {\n  async fetch(request: Request, env: TestEnv): Promise<Response> {\n    return (await handleArtifactRoute(request, env)) ?? a2a(request, env);\n  }\n} satisfies ExportedHandler<TestEnv>;\n';
+
+// src/agent/templates/test/test-worker.ts
+function testWorkerTs(spec2, n3) {
+  const T = `Test${n3.pascal}`;
+  return render(worker_ts_default, {
+    when: { subAgent: spec2.subAgent },
+    tokens: {
+      TENANT: spec2.tenant,
+      AGENT_CLASS: n3.agentClass,
+      HOST_CLASS: n3.hostClass,
+      WORKFLOW_CLASS: n3.workflowClass,
+      CHILD_CLASS: n3.childClass,
+      TEST_AGENT_CLASS: `${T}Agent`,
+      TEST_HOST_CLASS: `${T}Host`,
+      TEST_WORKFLOW_CLASS: `${T}Workflow`,
+      TEST_CHILD_CLASS: `${T}Child`,
+      // A token each rather than `TEST_$SCREAMING_HOST`, which the
+      // longest-run match would read as the single token `$SCREAMING_HOST`.
+      TEST_HOST_BINDING: `TEST_${n3.screaming}_HOST`,
+      TEST_AGENT_BINDING: `TEST_${n3.screaming}_AGENT`,
+      TEST_WORKFLOW_BINDING: `TEST_${n3.workflowBinding}`,
+      SUBAGENT_NOTE: spec2.subAgent ? " — and its sub-agent's —" : "",
+      // The overrides that break after the `=` past the print width.
+      HOST_BINDINGS: [
+        assigned(
+          "protected override readonly workflowBinding",
+          `TEST_${n3.workflowBinding}`
+        ),
+        assigned(
+          "protected override readonly hostBinding",
+          `TEST_${n3.screaming}_HOST`
+        )
+      ].join("\n"),
+      STEP_AGENT: assigned(
+        `protected override readonly ${n3.camel}`,
+        `TEST_${n3.screaming}_AGENT`
+      )
+    }
+  });
+}
+
+// src/agent/templates/test/turn.spec.ts.tpl
+var turn_spec_ts_default = 'import { describe, expect, it } from "vitest";\nimport { env } from "cloudflare:workers";\nimport {\n  createAgentHarness,\n  TERMINAL_CALLBACK_STATES,\n  type AgentHarness\n} from "@dynamicagents/core/testing";\nimport { copy } from "@/copy";\nimport worker, { type TestEnv } from "./worker";\n\n/**\n * `$TENANT`\'s A2A lifecycle, driven end to end through core\'s edge, its host\n * and its pipeline on a scripted model: every scenario goes in as a\n * gatekeeper-signed `SendMessage` and comes out as push callbacks.\n *\n * Core\'s own suite holds the lifecycle itself. What is checked here is that\n * **this** agent is wired into it: its host runs its pipeline on it, its soul\n * and plugins load, its retry is briefed$SUBAGENT_NOTE, and its words are the ones a\n * caller reads when something goes wrong.\n *\n * **One caller per spec.** An object runs its turns one at a time, so two specs\n * sharing a caller would serialize and see each other\'s callbacks.\n */\n\nconst testEnv = env as unknown as TestEnv;\n\nfunction harnessFor(label: string): AgentHarness {\n  return createAgentHarness({\n    worker,\n    env: testEnv,\n    tenant: "$TENANT",\n    identity: {\n      key: `$TENANT:${label}:${crypto.randomUUID()}`,\n      name: "Spec Caller",\n      kind: "custom",\n      workspaceId: 1\n    }\n  });\n}\n\nconst pause = (ms: number) => new Promise((r) => setTimeout(r, ms));\n\ndescribe("$TENANT", () => {\n  it("answers a turn and calls back exactly once", async () => {\n    const harness = harnessFor("turn");\n    using _ = harness.interceptGatekeeper();\n\n    const accepted = await harness.send("echo:hello there");\n    const done = await harness.waitForTerminal(accepted.id);\n    expect(done.state).toBe("TASK_STATE_COMPLETED");\n    expect(done.text).toBe("hello there");\n\n    await pause(300);\n    const terminals = harness.callbacks.filter(\n      (c) => c.taskId === accepted.id && TERMINAL_CALLBACK_STATES.has(c.state)\n    );\n    expect(terminals).toHaveLength(1);\n  });\n\n  it("runs a failed step once more, briefed as a retry", async () => {\n    const harness = harnessFor("flaky");\n    using _ = harness.interceptGatekeeper();\n\n    const accepted = await harness.send("flaky");\n    const done = await harness.waitForTerminal(accepted.id);\n    expect(done.state).toBe("TASK_STATE_COMPLETED");\n    // What `RETRY_BRIEF` (src/copy.ts) bought: the second attempt knows it is\n    // one, and carries on rather than starting again.\n    expect(done.text).toBe("recovered");\n  });\n\n  it("fails a turn that errors every time, in this project\'s words", async () => {\n    const harness = harnessFor("boom");\n    using _ = harness.interceptGatekeeper();\n\n    const accepted = await harness.send("boom");\n    const failed = await harness.waitForTerminal(accepted.id);\n    expect(failed.state).toBe("TASK_STATE_FAILED");\n    // The agent\'s words, from src/copy.ts — core ships none.\n    expect(failed.text).toBe(copy.failed);\n  });\n  // $when subAgent\n\n  it("hands a self-contained task to its sub-agent and composes the result", async () => {\n    const harness = harnessFor("delegate");\n    using _ = harness.interceptGatekeeper();\n\n    const accepted = await harness.send("delegate:summarize the handbook");\n    const done = await harness.waitForTerminal(accepted.id);\n    expect(done.state).toBe("TASK_STATE_COMPLETED");\n    expect(done.text).toContain("child did: summarize the handbook");\n  });\n  // $end\n});\n';
+
+// src/agent/templates/test/turn-spec.ts
+var turnSpec = (spec2) => render(turn_spec_ts_default, {
+  when: { subAgent: spec2.subAgent },
+  tokens: {
+    TENANT: spec2.tenant,
+    SUBAGENT_NOTE: spec2.subAgent ? ", its sub-agent is reachable under\n * the tool name its model is told" : ""
+  }
+});
+
+// src/agent/templates/test/manifest.spec.ts.tpl
+var manifest_spec_ts_default = 'import { describe, expect, it } from "vitest";\nimport { env } from "cloudflare:workers";\nimport { manifest } from "@/agents/$TENANT/manifest";\nimport { hostManifest } from "@/host-manifest";\nimport { plugins } from "@/agents/$TENANT/plugins";\n\n/**\n * The card a gatekeeper registers from.\n *\n * What it says is what callers believe this agent can do, so the assertions\n * here are about it staying true to the agent rather than about its prose.\n */\n\ndescribe("the agent card", () => {\n  it("names the agent and describes it", () => {\n    expect(manifest.name).not.toBe("");\n    expect(manifest.description).not.toBe("");\n  });\n\n  it("gives every skill a unique id, a name and a description", () => {\n    const ids = manifest.skills.map((skill) => skill.id);\n    expect(new Set(ids).size).toBe(ids.length);\n    for (const skill of manifest.skills) {\n      expect(skill.id).not.toBe("");\n      expect(skill.name).not.toBe("");\n      expect(skill.description).not.toBe("");\n    }\n  });\n\n  it("declares the protocol fields core cannot default", () => {\n    // `extensions` is a required (repeated) protobuf field in v1.0: empty is a\n    // declaration, absent is a protocol error. `capabilities` itself is\n    // optional in the SDK\'s type, which is why it is read through `?.` here.\n    expect(manifest.capabilities?.extensions).toEqual([]);\n    expect(manifest.capabilities?.pushNotifications).toBe(true);\n  });\n\n  it("advertises a browse skill only when the browser plugin is installed", () => {\n    // The assertion that keeps the card honest: a skill nobody can call is\n    // worse than a short card. `plugins()` is read rather than a literal, so\n    // adding or removing a capability fails here until the card follows.\n    const installed = plugins(env).map((plugin) => plugin.name);\n    const browses = manifest.skills.some((skill) => skill.id === "browse");\n    expect(browses).toBe(installed.includes("browser"));\n  });\n});\n\n/** The tenant this Worker mounts, as its stub card has to name it. */\nconst TENANT = "$TENANT";\n\ndescribe("the deployment\'s stub card", () => {\n  it("names every tenant this Worker mounts", () => {\n    // It is the only place this card says what is here, so a tenant missing\n    // from it is a tenant an operator reading the deploy cannot discover.\n    expect(hostManifest.description).toContain(TENANT);\n    // The skills belong to the tenants: a client picking one from here would\n    // have no way to act on it.\n    expect(hostManifest.skills).toEqual([]);\n  });\n});\n';
+
+// src/agent/templates/test/plugins.spec.ts.tpl
+var plugins_spec_ts_default = 'import { describe, expect, it } from "vitest";\nimport { env } from "cloudflare:workers";\nimport { plugins } from "@/agents/$TENANT/plugins";\n\n/**\n * The capabilities this agent installs, against the bindings this project\n * actually declares.\n *\n * A plugin declares what it needs and core checks it when the agent starts, so\n * a capability added without its `wrangler.jsonc` binding is an agent that\n * throws on its first request. This spec is that check, run in a second rather\n * than in production: it reads the `env` the pool builds from\n * `wrangler.jsonc`, so it fails the moment the two disagree.\n */\n\ndescribe("plugins", () => {\n  it("installs each capability once", () => {\n    const names = plugins(env).map((plugin) => plugin.name);\n    expect(new Set(names).size).toBe(names.length);\n  });\n\n  it("has every binding and secret its plugins require", () => {\n    const missing: string[] = [];\n    for (const plugin of plugins(env)) {\n      const required = [\n        ...(plugin.requires?.bindings ?? []),\n        ...(plugin.requires?.secrets ?? [])\n      ];\n      for (const key of required) {\n        if ((env as unknown as Record<string, unknown>)[key] == null) {\n          missing.push(`${plugin.name} needs ${key}`);\n        }\n      }\n    }\n    expect(missing).toEqual([]);\n  });\n});\n';
+
+// src/agent/templates/test/soul.spec.ts.tpl
+var soul_spec_ts_default = 'import { describe, expect, it } from "vitest";\nimport { ASK_GUIDANCE } from "@/copy";\n// $block SOUL_IMPORT\n\n/**\n * The rules the soul has to keep, as it is rewritten.\n *\n * It **will** be rewritten — it is the one file core refuses to ship and the\n * first one to edit. These are the two things easy to break while doing it.\n */\n\ndescribe("SOUL", () => {\n  it("says who the agent is and when to ask the person", () => {\n    expect(SOUL).toContain($NAME_LITERAL);\n    // `ask_user` stops the task and puts a question to a person. The guidance\n    // for when that is worth doing is shared copy, not this agent\'s words.\n    expect(SOUL).toContain(ASK_GUIDANCE);\n  });\n\n  it("describes no capability", () => {\n    // Every plugin tells the model what it can do in a context block of its\n    // own$SUBAGENT_NOTE — so removing one removes its advice with it. A\n    // capability named here would outlive the capability.\n    for (const claim of ["you can browse", "you have access to"]) {\n      expect(SOUL.toLowerCase()).not.toContain(claim);\n    }\n  });\n\n  it("tells the model what memory is for", () => {\n    expect(MEMORY).not.toBe("");\n  });\n});\n// $when subAgent\n\ndescribe("GENERAL_SOUL", () => {\n  it("writes to a sub-agent that cannot see this conversation", () => {\n    // The distinction is structural rather than stylistic: a sub-agent is\n    // handed one self-contained task and nothing else, so a soul written as\n    // though it could see the conversation is how it ends up asking a follow-up\n    // question nobody will ever read.\n    expect(GENERAL_SOUL).toContain("self-contained");\n    expect(GENERAL_SOUL).toMatch(/do not ask follow-up questions/i);\n  });\n});\n// $end\n';
+
+// src/agent/templates/test/tuning.spec.ts.tpl
+var tuning_spec_ts_default = 'import { describe, expect, it } from "vitest";\nimport { TUNING } from "@/agents/$TENANT/tuning";\n\n/**\n * The numbers. Core ships none, so these are the project\'s — and two of them\n * are wrong in ways nothing else notices until a long conversation.\n */\n\ndescribe("TUNING", () => {\n  it("keeps less than it compacts", () => {\n    // The tail kept verbatim has to fit inside the budget that triggers\n    // compaction, or compaction can never make the history smaller.\n    expect(TUNING.keepRecentTokens).toBeLessThan(TUNING.compactAfterTokens);\n  });\n\n  it("backs off from a floor rather than down to one", () => {\n    // The wait doubles from `afterMs` up to `maxMs`, so a ceiling below the\n    // floor is a backoff that never happens and a number that reads as if it\n    // bounds something.\n    expect(TUNING.reconcile.afterMs).toBeLessThanOrEqual(\n      TUNING.reconcile.maxMs\n    );\n  });\n\n  it("names models the catalogue has", () => {\n    const modelId = $MODEL_ID_RE;\n    expect(TUNING.modelId).toMatch(modelId);\n    expect(TUNING.compactionModelId).toMatch(modelId);\n  });\n});\n';
+
+// src/agent/templates/test/unit-specs.ts
+var soulSpec = (spec2) => render(soul_spec_ts_default, {
+  when: { subAgent: spec2.subAgent },
+  tokens: {
+    /**
+     * The one import here that is laid out rather than written: with the
+     * sub-agent's `GENERAL_SOUL` it is three names, and prettier breaks it
+     * one per line once a long tenant pushes the line past the print width.
+     */
+    SOUL_IMPORT: namedFrom(
+      "import",
+      ["MEMORY", "SOUL", ...spec2.subAgent ? ["GENERAL_SOUL"] : []],
+      `@/agents/${spec2.tenant}/soul`
+    ),
+    NAME_LITERAL: JSON.stringify(spec2.name),
+    SUBAGENT_NOTE: spec2.subAgent ? ", and each sub-agent in its tool's description" : ""
+  }
+});
+var manifestSpec = (spec2) => render(manifest_spec_ts_default, { tokens: { TENANT: spec2.tenant } });
+var tuningSpec = (spec2) => render(tuning_spec_ts_default, {
+  tokens: {
+    TENANT: spec2.tenant,
+    // The same regex the CLI validated the id with, read from `../../names.ts`
+    // rather than written twice: a generated project asserting a rule this
+    // one does not enforce is a project that fails its own suite.
+    MODEL_ID_RE: MODEL_ID_RE.toString()
+  }
+});
+var pluginsSpec = (spec2) => render(plugins_spec_ts_default, { tokens: { TENANT: spec2.tenant } });
+
+// src/agent/files.ts
+function projectFiles(spec2) {
+  const n3 = names(spec2.tenant);
+  const file = (path3, contents) => ({
+    path: path3,
+    contents
+  });
+  return [
+    file("package.json", packageJson(spec2)),
+    file("wrangler.jsonc", wranglerJsonc(spec2, n3)),
+    file("tsconfig.json", tsconfigJson),
+    file("vitest.config.ts", vitestConfigTs(spec2, n3)),
+    file("eslint.config.js", eslintConfigJs),
+    file(".prettierrc", prettierrc),
+    file(".prettierignore", prettierignore),
+    file(".gitignore", gitignore),
+    file(".nvmrc", nvmrc),
+    file(".env.example", envExample(spec2)),
+    file("README.md", readmeMd(spec2, n3)),
+    file("AGENTS.md", agentsMd(spec2, n3)),
+    file("src/index.ts", indexTs(spec2, n3)),
+    file("src/host-manifest.ts", hostManifestTs(spec2)),
+    file("src/copy.ts", copyTs),
+    file("src/model.ts", modelTs),
+    file(`${n3.dir}/definition.ts`, definitionTs(spec2, n3)),
+    file(`${n3.dir}/host.ts`, hostTs(n3)),
+    file(`${n3.dir}/workflow.ts`, workflowTs(n3)),
+    file(`${n3.dir}/agent.ts`, agentTs(spec2, n3)),
+    ...spec2.subAgent ? [file(`${n3.dir}/children.ts`, childrenTs(n3))] : [],
+    file(`${n3.dir}/manifest.ts`, manifestTs(spec2)),
+    file(`${n3.dir}/plugins.ts`, pluginsTs(spec2)),
+    file(`${n3.dir}/soul.ts`, soulTs(spec2)),
+    file(`${n3.dir}/tuning.ts`, tuningTs(spec2)),
+    file("test/tsconfig.json", testTsconfigJson),
+    file("test/worker.ts", testWorkerTs(spec2, n3)),
+    file("test/turn.spec.ts", turnSpec(spec2)),
+    file("test/edge.spec.ts", edgeSpec(spec2)),
+    file("test/soul.spec.ts", soulSpec(spec2)),
+    file("test/manifest.spec.ts", manifestSpec(spec2)),
+    file("test/tuning.spec.ts", tuningSpec(spec2)),
+    file("test/plugins.spec.ts", pluginsSpec(spec2))
+  ];
+}
+
+// src/cli/existing.ts
+var IGNORABLE = [
+  // A repository made before the tool ran.
+  ".git",
+  ".hg",
+  ".svn",
+  // The placeholder that made the empty directory in the first place.
+  ".gitkeep",
+  ".keep",
+  // An editor was opened on it.
+  ".idea",
+  ".vscode",
+  // Finder and Explorer, writing without being asked.
+  ".DS_Store",
+  "Thumbs.db",
+  "desktop.ini"
+];
+var names2 = new Set(IGNORABLE.map((entry) => entry.toLowerCase()));
+var ignorable = (entry) => names2.has(entry.toLowerCase());
+var blocking = (entries) => entries.filter((entry) => !ignorable(entry));
+
+// src/cli/plan.ts
+var stateOf = (entries) => entries.length === 0 ? "empty" : blocking(entries).length === 0 ? "ignorable" : "occupied";
+var whyNotTarget = (target2) => target2.state === "occupied" ? notEmpty(target2.named) : void 0;
+function plan(spec2, target2) {
+  const refuse = (problem2) => ({ ok: false, problem: problem2 });
+  const answers = [
+    asBlueprint(spec2.blueprint),
+    asTenant(spec2.tenant),
+    asModelId(spec2.modelId),
+    asDescription(spec2.description)
+  ];
+  for (const answer of answers) {
+    if ("problem" in answer) return refuse(answer.problem);
+  }
+  const problem = whyNotTarget(target2);
+  if (problem !== void 0) return refuse(problem);
+  return { ok: true, plan: { spec: spec2, target: target2, files: projectFiles(spec2) } };
+}
+
+// src/cli/write.ts
+import {
+  lstat,
+  mkdir,
+  mkdtemp,
+  readdir,
+  rename,
+  rm,
+  rmdir,
+  writeFile
+} from "node:fs/promises";
+import path from "node:path";
+var TargetChanged = class extends Error {
+  constructor(target2, found) {
+    super(`${target2} is no longer empty: ${found.join(", ")}`);
+    this.target = target2;
+    this.found = found;
+    this.name = "TargetChanged";
+  }
+  target;
+  found;
+};
+async function entriesAt(dir) {
+  try {
+    return await readdir(dir);
+  } catch (err) {
+    const { code } = err;
+    if (code === "ENOENT") return [];
+    if (code === "ENOTDIR") throw new TargetChanged(dir, [path.basename(dir)]);
+    throw err;
+  }
+}
+var taken = (at) => lstat(at).then(
+  () => true,
+  () => false
+);
+async function commitEntries(staging, target2) {
+  const landed = [];
+  try {
+    for (const entry of (await readdir(staging)).sort()) {
+      const to = path.join(target2, entry);
+      if (await taken(to)) throw new TargetChanged(target2, [entry]);
+      await rename(path.join(staging, entry), to);
+      landed.push(entry);
+    }
+  } catch (err) {
+    for (const entry of landed.reverse()) {
+      await rename(path.join(target2, entry), path.join(staging, entry)).catch(
+        () => void 0
+      );
+    }
+    throw err;
+  }
+  await rmdir(staging).catch(() => void 0);
+}
+async function commit(staging, target2) {
+  const existing = await entriesAt(target2);
+  if (existing.length === 0) {
+    await rmdir(target2).catch(() => void 0);
+    await rename(staging, target2);
+    return;
+  }
+  const blocked = blocking(existing);
+  if (blocked.length > 0) throw new TargetChanged(target2, blocked);
+  await commitEntries(staging, target2);
+}
+async function writeProject(target2, files) {
+  const parent = path.dirname(target2);
+  await mkdir(parent, { recursive: true });
+  const staging = await mkdtemp(path.join(parent, ".dynamicagents-"));
+  try {
+    for (const file of files) {
+      const full = path.join(staging, file.path);
+      await mkdir(path.dirname(full), { recursive: true });
+      await writeFile(full, file.contents, "utf8");
+    }
+    await commit(staging, target2);
+  } catch (err) {
+    await rm(staging, { recursive: true, force: true });
+    throw err;
+  }
+}
+
+// src/cli.ts
+var { version } = JSON.parse(
+  readFileSync(new URL("../package.json", import.meta.url), "utf8")
+);
+var argv = read(process.argv.slice(2));
+var print = (text2) => new Promise((resolve) => {
+  process.stdout.write(`${text2}
+`, () => resolve());
+});
+if (argv.want === "help") {
+  await print(help(version));
+  process.exit(0);
+}
+if (argv.want === "version") {
+  await print(version);
+  process.exit(0);
+}
+var interactive = process.stdin.isTTY === true;
+var hyperlinks = interactive && (process.env.TERM_PROGRAM !== void 0 || process.env.WT_SESSION !== void 0);
+function stop(message) {
+  log.error(message);
+  cancel(nothingBuilt);
+  process.exit(1);
+}
+function answered(value) {
+  if (isCancel(value)) {
+    cancel(nothingBuilt);
+    process.exit(1);
+  }
+  return value;
+}
+async function settle(reply, ask) {
+  if (reply.kind === "use") return reply.value;
+  if (reply.kind === "stop") stop(reply.problem);
+  if (reply.problem !== void 0) log.warn(reply.problem);
+  return answered(await ask(reply.initial));
+}
+var typed = (answer) => typeof answer === "string" ? answer.trim() : answer;
+async function optional(flag, ask, fallback) {
+  if (flag !== void 0) return flag;
+  if (!interactive) return fallback;
+  return answered(await ask());
+}
+intro(title(version));
+if (argv.want === "trouble") stop(badArgument(argv.trouble));
+var { flags, positionals } = argv;
+async function targetState(dir) {
+  try {
+    const info = await stat(dir);
+    if (!info.isDirectory()) return "occupied";
+    return stateOf(await readdir2(dir));
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+    return "free";
+  }
+}
+async function targetAt(named) {
+  const dir = path2.resolve(process.cwd(), named);
+  let state;
+  try {
+    state = await targetState(dir);
+  } catch (err) {
+    stop(cannotRead(named, err.message));
+  }
+  const target2 = { named, dir, state };
+  const problem = whyNotTarget(target2);
+  if (problem !== void 0) stop(problem);
+  return target2;
+}
+var askModelId2 = (initial) => text({
+  message: askModelId,
+  placeholder: DEFAULT_MODEL_ID,
+  initialValue: initial,
+  validate: whyNot(asModelId)
+});
+async function chooseModel() {
+  const choice = answered(
+    await select({
+      message: askModel,
+      options: [
+        { value: "default", label: defaultModelLabel },
+        { value: "other", label: otherModelLabel(hyperlinks) }
+      ]
+    })
+  );
+  if (choice === "default") return DEFAULT_MODEL_ID;
+  return typed(await askModelId2());
+}
+var kind = await settle(
+  replyTo(positionals[0], asKind, { interactive }),
+  () => select({
+    message: question,
+    options: KINDS.map((entry) => ({
+      value: entry,
+      label: entry.label,
+      hint: entry.hint
+    }))
+  })
+);
+if (!kind.ready) {
+  note(kind.about, kind.label, { format: (line) => line.trimStart() });
+  outro(workInProgress(kind));
+  process.exit(0);
+}
+var namedDir = flags.dir ?? positionals[2];
+var judgedDir = namedDir === void 0 ? void 0 : await targetAt(namedDir);
+var blueprint = await settle(
+  replyTo(positionals[1], asBlueprint, { interactive }),
+  () => select({
+    message: whichAgent,
+    options: BLUEPRINTS.map((entry) => ({
+      value: entry,
+      label: entry.label,
+      hint: entry.hint
+    }))
+  })
+);
+var tenant = await settle(
+  replyTo(flags.name, asTenant, { interactive, named: "--name" }),
+  async (initial) => typed(
+    await text({
+      message: askTenant,
+      placeholder: tenantPlaceholder,
+      initialValue: initial,
+      validate: whyNot(asTenant)
+    })
+  )
+);
+var description = await settle(
+  replyTo(flags.description, asDescription, {
+    interactive,
+    named: "--description"
+  }),
+  async (initial) => typed(
+    await text({
+      message: askDescription,
+      placeholder: descriptionPlaceholder,
+      initialValue: initial,
+      validate: whyNot(asDescription)
+    })
+  )
+);
+var subAgent = await optional(
+  flags.subagent,
+  () => confirm({ message: askSubAgent, initialValue: true }),
+  true
+);
+var capabilities = await optional(
+  flags.browser === true ? ["browser"] : flags.browser === false ? [] : void 0,
+  () => multiselect({
+    message: askCapabilities,
+    options: CAPABILITIES.map((capability) => ({
+      value: capability.value,
+      label: capability.label,
+      hint: capability.hint
+    })),
+    // Nothing is pre-selected: a capability arrives because it was asked for,
+    // never because it was the default.
+    initialValues: [],
+    required: false
+  }),
+  []
+);
+var modelId = await settle(
+  replyTo(flags.model, asModelId, {
+    interactive,
+    named: "--model",
+    fallback: DEFAULT_MODEL_ID
+  }),
+  // A `--model` that will not do means a model was chosen deliberately, so the
+  // menu is skipped and the id itself is asked for, on what was typed.
+  async (initial) => initial === void 0 ? chooseModel() : typed(await askModelId2(initial))
+);
+var target = judgedDir ?? await targetAt(tenant);
+var spec = {
+  tenant,
+  name: displayName(tenant),
+  description,
+  blueprint: blueprint.value,
+  subAgent,
+  capabilities,
+  modelId
+};
+var planned = plan(spec, target);
+if (!planned.ok) stop(planned.problem);
+note(tree(target.named, planned.plan.files), blueprint.label);
+if (flags["dry-run"] === true) {
+  outro(dryRun);
+  process.exit(0);
+}
+if (flags.yes !== true && interactive) {
+  const go = answered(await confirm({ message: confirmWrite }));
+  if (!go) {
+    cancel(nothingBuilt);
+    process.exit(1);
+  }
+}
+try {
+  await writeProject(target.dir, planned.plan.files);
+} catch (err) {
+  if (!(err instanceof TargetChanged)) throw err;
+  stop(notEmpty(target.named));
+}
+log.success(wrote(target.named));
+var installing2 = spinner();
+installing2.start(installing);
+try {
+  await installProject(target.dir, (step) => installing2.message(step));
+  installing2.stop(installed);
+} catch (err) {
+  installing2.stop(installing);
+  log.error(finishByHand(target.named, err.message));
+  cancel(notInstalled(spec.name));
+  process.exit(1);
+}
+note(nextSteps(target.named, tenant), "Next");
+outro(outroLine(spec.name));