@rubytech/create-realagent-code 0.1.265 → 0.1.267

package/payload/platform/templates/account.json

@@ -5,7 +5,7 @@
   "publicModel": "claude-haiku-4-5",
   "outputStyle": "default",
   "thinkingView": "default",
-  "effort": "auto",
+  "effort": "medium",
   "enabledPlugins": [],
   "defaultAgent": "",
   "admins": []

package/payload/platform/templates/specialists/agents/content-producer.md

@@ -2,7 +2,7 @@
 name: content-producer
 description: "Author professional business documents (proposal, report, brief, memo, plan, case study, brochure), render PDFs, generate images, and publish static websites. Delegate when the operator asks for a written document, a PDF render, a generated image, or to publish a prepared website."
 summary: "Produces visual output from your graph: generates images, renders pages to PDF, and hosts static websites you upload as a zip."
-model: claude-opus-4-8
+model: claude-opus-4-8[1m]
 tools: Bash, Read, Edit, Write, MultiEdit, Skill, mcp__plugin_memory_memory__memory-search, mcp__plugin_replicate_replicate__image-generate, mcp__plugin_browser_browser__browser-render, mcp__plugin_browser_browser__browser-navigate, mcp__plugin_browser_browser__browser-evaluate, mcp__plugin_browser_browser__browser-resize, mcp__plugin_browser_browser__browser-screenshot, mcp__plugin_browser_browser__browser-pdf-save, mcp__plugin_admin_admin__plugin-read, mcp__plugin_admin_admin__public-hostname, mcp__plugin_admin_admin__publish-site
 ---
 

package/payload/platform/templates/specialists/agents/librarian.md

@@ -2,7 +2,7 @@
 name: librarian
 description: "Ingest documents (PDF, text, web pages), conversation transcripts (WhatsApp, Telegram, iMessage, Slack, meeting minutes), and LinkedIn exports into the memory graph. Delegate when the operator hands you a file or transcript that should land in the graph."
 summary: "Owns foreground ingest of documents, conversation transcripts, and external archives into the memory graph."
-model: claude-sonnet-4-5
+model: claude-opus-4-8[1m]
 tools: mcp__plugin_memory_memory__memory-ingest-extract, mcp__plugin_memory_memory__memory-ingest, mcp__plugin_memory_memory__memory-ingest-web, mcp__plugin_memory_memory__memory-archive-write, mcp__plugin_memory_memory__memory-write, mcp__plugin_memory_memory__memory-update, mcp__plugin_memory_memory__memory-edge, mcp__plugin_memory_memory__memory-search, mcp__plugin_memory_memory__conversation-archive-list-chunks, mcp__plugin_memory_memory__conversation-archive-derive-insights, mcp__plugin_memory_memory__conversation-archive-enrich-rejection, mcp__plugin_contacts_contacts__contact-create, mcp__plugin_work_work__work-create, mcp__plugin_url-get_url-get__url-get, Read, Bash, Skill, WebFetch
 ---
 

package/payload/platform/templates/specialists/agents/research-assistant.md

@@ -2,7 +2,7 @@
 name: research-assistant
 description: "Deep research on the web, knowledge management, and writing structured summaries with citations from multiple sources. Delegate when the operator wants you to research a topic, read web pages, combine findings into a summary, or reorganise stored knowledge."
 summary: "Researches topics online, manages your knowledge graph, and produces supporting visuals."
-model: claude-opus-4-7
+model: claude-opus-4-8[1m]
 tools: WebSearch, WebFetch, Skill, mcp__plugin_memory_memory__memory-search, mcp__plugin_memory_memory__memory-write, mcp__plugin_memory_memory__memory-reindex, mcp__plugin_replicate_replicate__image-generate, mcp__plugin_browser_browser__browser-render, mcp__plugin_url-get_url-get__url-get
 ---
 

package/payload/premium-plugins/real-agent/plugins/brochures/skills/property-brochure/SKILL.md

@@ -95,7 +95,7 @@ If the operator did **not** request socials, do not run the step; adding 1 to 3
 
 ## Step 4 — populate, render, deliver
 
-**Before writing any copy, call `voice-retrieve-conditioning`** with `format: "article"`, `length: "long"`, and `topic` set to the property's `addressLocality` or the marketing angle (e.g. "period townhouse in Hackney"). When the tool returns a non-null `styleCard`, condition the long-form narrative copy on it — the style card + exemplars feed the editorial copy register; brand-required structure rules still override. When the tool returns `{styleCard: null, exemplars: []}` (no operator voice profile yet, or `writer-craft` not enabled), fall back to the unconditioned register documented in `references/copy.md`. Emit narration `[property-brochure] voice-mirror styleCardBytes=<n> exemplars=<k>` when conditioning was applied.
+**Before writing any copy, call `voice-retrieve-conditioning`** with `format: "article"`, `length: "long"`, `scope: "org"`, and `topic` set to the property's `addressLocality` or the marketing angle (e.g. "period townhouse in Hackney"). A brochure goes out under the agency's name, so it uses the **house voice** (`scope: "org"`), not any one operator's personal voice. When the tool returns a non-null `styleCard` (`status` of `ok` or `fallback-org`), condition the long-form narrative copy on it — the style card + exemplars feed the editorial copy register; brand-required structure rules still override. When `status` is `no-data` or `error`, fall back to the unconditioned register documented in `references/copy.md`. Emit narration `[property-brochure] voice-mirror styleCardBytes=<n> exemplars=<k>` when conditioning was applied.
 
 Read the seller brief once before writing any copy. Then walk the `{{ placeholder }}` tokens in both files top-to-bottom, substituting from the brief and `property.json`. The complete substitution contract — every token, its source field, its expected format and voice — lives in [references/placeholders.md](references/placeholders.md). Each token also has an inline `<!-- REPLACE: ... -->` comment in the template giving the short version.
 

package/payload/server/{chunk-SOLVVUST.js → chunk-W4EM7RK4.js}

@@ -5590,6 +5590,8 @@ var clientIpMiddleware = async (c, next) => {
 };
 
 export {
+  HtmlEscapedCallbackPhase,
+  resolveCallback,
   Hono2 as Hono,
   getRequestListener,
   serve,

package/payload/server/maxy-edge.js

@@ -14,7 +14,7 @@ import {
   sanitizeClientCorrId,
   vncLog,
   websockifyLog
-} from "./chunk-SOLVVUST.js";
+} from "./chunk-W4EM7RK4.js";
 import "./chunk-PFF6I7KP.js";
 
 // server/edge.ts

package/payload/server/server.js

@@ -9,6 +9,7 @@ import {
   COMMERCIAL_MODE,
   GREETING_DIRECTIVE,
   Hono,
+  HtmlEscapedCallbackPhase,
   INSTALL_OWNER_FILE,
   LOG_DIR,
   MAXY_DIR,
@@ -71,6 +72,7 @@ import {
   requirePortEnv,
   resolveAccount,
   resolveAgentConfig,
+  resolveCallback,
   resolveClientIp,
   resolveDefaultAgentSlug,
   resolveUserAccounts,
@@ -93,7 +95,7 @@ import {
   vncLog,
   walkPremiumBundles,
   writeAdminUserAndPerson
-} from "./chunk-SOLVVUST.js";
+} from "./chunk-W4EM7RK4.js";
 import {
   __commonJS,
   __toESM
@@ -1105,24 +1107,24 @@ var pr54206Applied = () => {
   return major >= 23 || major === 22 && minor >= 7 || major === 20 && minor >= 18;
 };
 var useReadableToWeb = pr54206Applied();
-var createStreamBody = (stream) => {
+var createStreamBody = (stream2) => {
   if (useReadableToWeb) {
-    return Readable.toWeb(stream);
+    return Readable.toWeb(stream2);
   }
   const body = new ReadableStream({
     start(controller) {
-      stream.on("data", (chunk) => {
+      stream2.on("data", (chunk) => {
         controller.enqueue(chunk);
       });
-      stream.on("error", (err) => {
+      stream2.on("error", (err) => {
         controller.error(err);
       });
-      stream.on("end", () => {
+      stream2.on("end", () => {
         controller.close();
       });
     },
     cancel() {
-      stream.destroy();
+      stream2.destroy();
     }
   });
   return body;
@@ -1227,10 +1229,10 @@ var serveStatic = (options = { root: "" }) => {
         end = size - 1;
       }
       const chunksize = end - start + 1;
-      const stream = createReadStream(path2, { start, end });
+      const stream2 = createReadStream(path2, { start, end });
       c.header("Content-Length", chunksize.toString());
       c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
-      result = c.body(createStreamBody(stream), 206);
+      result = c.body(createStreamBody(stream2), 206);
     }
     await options.onFound?.(path2, c);
     return result;
@@ -2892,9 +2894,9 @@ function getDownloadableContent(message) {
   if (msg.stickerMessage) return { downloadable: msg.stickerMessage, mediaType: "sticker" };
   return void 0;
 }
-async function streamToBuffer(stream) {
+async function streamToBuffer(stream2) {
   const chunks = [];
-  for await (const chunk of stream) {
+  for await (const chunk of stream2) {
     chunks.push(Buffer.from(chunk));
   }
   return Buffer.concat(chunks);
@@ -2925,8 +2927,8 @@ async function downloadInboundMedia(msg, sock, opts) {
       const downloadable = getDownloadableContent(content);
       if (downloadable) {
         try {
-          const stream = await downloadContentFromMessage(downloadable.downloadable, downloadable.mediaType);
-          buffer = await streamToBuffer(stream);
+          const stream2 = await downloadContentFromMessage(downloadable.downloadable, downloadable.mediaType);
+          buffer = await streamToBuffer(stream2);
         } catch (fallbackErr) {
           console.error(`${TAG8} direct download fallback failed: ${String(fallbackErr)}`);
         }
@@ -4671,7 +4673,8 @@ async function managerRcSpawn(opts) {
       initialMessage: opts.initialMessage,
       closeAfterTurn: opts.closeAfterTurn,
       sliceToken: opts.sliceToken,
-      personId: opts.personId
+      personId: opts.personId,
+      waChannel: opts.waChannel
     })
   }).catch((err) => ({ __throw: err instanceof Error ? err.message : String(err) }));
   if ("__throw" in res) {
@@ -15567,6 +15570,300 @@ function startReaper2() {
   startReaper();
 }
 
+// app/lib/whatsapp/gateway/inbound-hub.ts
+var InboundHub = class {
+  senders = /* @__PURE__ */ new Map();
+  state(senderId) {
+    let s = this.senders.get(senderId);
+    if (!s) {
+      s = { subscriber: null, queue: [] };
+      this.senders.set(senderId, s);
+    }
+    return s;
+  }
+  /** Route an inbound message to its sender. Delivers immediately if that
+   *  sender's channel server is attached; otherwise queues it (cold start). */
+  deliver(payload) {
+    const s = this.state(payload.senderId);
+    if (s.subscriber) {
+      s.subscriber(payload);
+    } else {
+      s.queue.push(payload);
+    }
+  }
+  /** A sender's channel server connected. Drain any queued messages to it in
+   *  arrival order, then route live. Replaces any prior subscriber. */
+  attach(senderId, subscriber) {
+    const s = this.state(senderId);
+    s.subscriber = subscriber;
+    if (s.queue.length > 0) {
+      const pending = s.queue;
+      s.queue = [];
+      for (const payload of pending) subscriber(payload);
+    }
+  }
+  /** A sender's channel server disconnected (session ended/restarting).
+   *  Subsequent messages queue again until re-attach, so nothing is lost
+   *  across a restart. */
+  detach(senderId) {
+    const s = this.senders.get(senderId);
+    if (s) s.subscriber = null;
+  }
+  /** Whether a sender currently has a live channel server. The gateway uses
+   *  this to decide whether an inbound needs a cold-start spawn/resume. */
+  hasSubscriber(senderId) {
+    return this.senders.get(senderId)?.subscriber != null;
+  }
+};
+
+// node_modules/hono/dist/utils/stream.js
+var StreamingApi = class {
+  writer;
+  encoder;
+  writable;
+  abortSubscribers = [];
+  responseReadable;
+  /**
+   * Whether the stream has been aborted.
+   */
+  aborted = false;
+  /**
+   * Whether the stream has been closed normally.
+   */
+  closed = false;
+  constructor(writable, _readable) {
+    this.writable = writable;
+    this.writer = writable.getWriter();
+    this.encoder = new TextEncoder();
+    const reader = _readable.getReader();
+    this.abortSubscribers.push(async () => {
+      await reader.cancel();
+    });
+    this.responseReadable = new ReadableStream({
+      async pull(controller) {
+        const { done, value } = await reader.read();
+        done ? controller.close() : controller.enqueue(value);
+      },
+      cancel: () => {
+        this.abort();
+      }
+    });
+  }
+  async write(input) {
+    try {
+      if (typeof input === "string") {
+        input = this.encoder.encode(input);
+      }
+      await this.writer.write(input);
+    } catch {
+    }
+    return this;
+  }
+  async writeln(input) {
+    await this.write(input + "\n");
+    return this;
+  }
+  sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+  }
+  async close() {
+    try {
+      await this.writer.close();
+    } catch {
+    }
+    this.closed = true;
+  }
+  async pipe(body) {
+    this.writer.releaseLock();
+    await body.pipeTo(this.writable, { preventClose: true });
+    this.writer = this.writable.getWriter();
+  }
+  onAbort(listener) {
+    this.abortSubscribers.push(listener);
+  }
+  /**
+   * Abort the stream.
+   * You can call this method when stream is aborted by external event.
+   */
+  abort() {
+    if (!this.aborted) {
+      this.aborted = true;
+      this.abortSubscribers.forEach((subscriber) => subscriber());
+    }
+  }
+};
+
+// node_modules/hono/dist/helper/streaming/utils.js
+var isOldBunVersion = () => {
+  const version = typeof Bun !== "undefined" ? Bun.version : void 0;
+  if (version === void 0) {
+    return false;
+  }
+  const result = version.startsWith("1.1") || version.startsWith("1.0") || version.startsWith("0.");
+  isOldBunVersion = () => result;
+  return result;
+};
+
+// node_modules/hono/dist/helper/streaming/sse.js
+var SSEStreamingApi = class extends StreamingApi {
+  constructor(writable, readable) {
+    super(writable, readable);
+  }
+  async writeSSE(message) {
+    const data = await resolveCallback(message.data, HtmlEscapedCallbackPhase.Stringify, false, {});
+    const dataLines = data.split(/\r\n|\r|\n/).map((line) => {
+      return `data: ${line}`;
+    }).join("\n");
+    for (const key of ["event", "id", "retry"]) {
+      if (message[key] && /[\r\n]/.test(message[key])) {
+        throw new Error(`${key} must not contain "\\r" or "\\n"`);
+      }
+    }
+    const sseData = [
+      message.event && `event: ${message.event}`,
+      dataLines,
+      message.id && `id: ${message.id}`,
+      message.retry && `retry: ${message.retry}`
+    ].filter(Boolean).join("\n") + "\n\n";
+    await this.write(sseData);
+  }
+};
+var run = async (stream2, cb, onError) => {
+  try {
+    await cb(stream2);
+  } catch (e) {
+    if (e instanceof Error && onError) {
+      await onError(e, stream2);
+      await stream2.writeSSE({
+        event: "error",
+        data: e.message
+      });
+    } else {
+      console.error(e);
+    }
+  } finally {
+    stream2.close();
+  }
+};
+var contextStash = /* @__PURE__ */ new WeakMap();
+var streamSSE = (c, cb, onError) => {
+  const { readable, writable } = new TransformStream();
+  const stream2 = new SSEStreamingApi(writable, readable);
+  if (isOldBunVersion()) {
+    c.req.raw.signal.addEventListener("abort", () => {
+      if (!stream2.closed) {
+        stream2.abort();
+      }
+    });
+  }
+  contextStash.set(stream2.responseReadable, c);
+  c.header("Transfer-Encoding", "chunked");
+  c.header("Content-Type", "text/event-stream");
+  c.header("Cache-Control", "no-cache");
+  c.header("Connection", "keep-alive");
+  run(stream2, cb, onError);
+  return c.newResponse(stream2.responseReadable);
+};
+
+// app/lib/whatsapp/gateway/routes.ts
+function createWaChannelRoutes(deps) {
+  const app45 = new Hono();
+  app45.get("/wa-channel/inbound", (c) => {
+    const senderId = c.req.query("senderId");
+    if (!senderId) return c.json({ error: "senderId required" }, 400);
+    return streamSSE(c, async (stream2) => {
+      deps.hub.attach(senderId, (payload) => {
+        void stream2.writeSSE({ data: JSON.stringify(payload) });
+      });
+      console.error(`[whatsapp-native] op=channel-attached senderId=${senderId}`);
+      stream2.onAbort(() => {
+        deps.hub.detach(senderId);
+        console.error(`[whatsapp-native] op=channel-detached senderId=${senderId}`);
+      });
+      while (!stream2.aborted) {
+        await stream2.sleep(15e3);
+        await stream2.writeSSE({ data: "", event: "ping" });
+      }
+    });
+  });
+  app45.post("/wa-channel/reply", async (c) => {
+    const body = await c.req.json().catch(() => null);
+    const senderId = body?.senderId;
+    const text = body?.text;
+    if (typeof senderId !== "string" || typeof text !== "string") {
+      return c.json({ error: "senderId and text required" }, 400);
+    }
+    const bytes = Buffer.byteLength(text, "utf8");
+    try {
+      await deps.sendOutbound(senderId, text);
+    } catch (err) {
+      console.error(
+        `[whatsapp-native] op=reply-failed senderId=${senderId} bytes=${bytes} error=${err instanceof Error ? err.message : String(err)}`
+      );
+      return c.json({ error: "send-failed" }, 500);
+    }
+    console.error(`[whatsapp-native] op=reply-dispatch senderId=${senderId} bytes=${bytes}`);
+    return c.json({ ok: true });
+  });
+  app45.post("/wa-channel/ready", async (c) => {
+    const body = await c.req.json().catch(() => null);
+    const senderId = body?.senderId;
+    if (typeof senderId !== "string") {
+      return c.json({ error: "senderId required" }, 400);
+    }
+    deps.onReady?.(senderId);
+    return c.json({ ok: true });
+  });
+  return app45;
+}
+
+// app/lib/whatsapp/gateway/wa-gateway.ts
+var WaGateway = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  hub = new InboundHub();
+  replies = /* @__PURE__ */ new Map();
+  spawning = /* @__PURE__ */ new Set();
+  seq = 0;
+  /** Hono sub-app exposing the loopback channel routes; mount on the UI app. */
+  routes() {
+    return createWaChannelRoutes({
+      hub: this.hub,
+      sendOutbound: (senderId, text) => this.sendOutbound(senderId, text)
+    });
+  }
+  /** Handle one inbound admin WhatsApp message. */
+  async handleInbound(input) {
+    const bytes = Buffer.byteLength(input.text, "utf8");
+    const hadSubscriber = this.hub.hasSubscriber(input.senderId);
+    this.replies.set(input.senderId, input.reply);
+    this.hub.deliver({ senderId: input.senderId, text: input.text, waMessageId: `wa-${++this.seq}` });
+    console.error(
+      `[whatsapp-native] op=inbound senderId=${input.senderId} accountId=${input.accountId} bytes=${bytes} delivery=${hadSubscriber ? "immediate" : "queued"}`
+    );
+    if (!hadSubscriber && !this.spawning.has(input.senderId)) {
+      this.spawning.add(input.senderId);
+      console.error(`[whatsapp-native] op=spawn-trigger senderId=${input.senderId}`);
+      try {
+        await this.deps.ensureChannelSession({
+          accountId: input.accountId,
+          senderId: input.senderId,
+          gatewayUrl: this.deps.gatewayUrl,
+          serverPath: this.deps.serverPath
+        });
+      } finally {
+        this.spawning.delete(input.senderId);
+      }
+    }
+  }
+  async sendOutbound(senderId, text) {
+    const reply = this.replies.get(senderId);
+    if (!reply) throw new Error(`wa-gateway: no reply route for sender ${senderId}`);
+    await reply(text);
+  }
+};
+
 // app/lib/admin-sse-registry.ts
 var activeAdminSSEControllers = /* @__PURE__ */ new Set();
 function broadcastAdminShutdown(reason) {
@@ -16524,6 +16821,23 @@ app44.all("*", (c) => {
 });
 var port = requirePortEnv("MAXY_UI_INTERNAL_PORT", { tag: "ui-server" });
 var hostname = process.env.HOSTNAME ?? "127.0.0.1";
+var waNativeGatewayUrl = `http://127.0.0.1:${port}`;
+var waChannelServerPath = process.env.MAXY_WA_CHANNEL_SERVER_PATH ?? resolve26(process.env.MAXY_PLATFORM_ROOT ?? join18(__dirname, ".."), "services/whatsapp-channel/dist/server.js");
+var waGateway = new WaGateway({
+  gatewayUrl: waNativeGatewayUrl,
+  serverPath: waChannelServerPath,
+  ensureChannelSession: async ({ accountId, senderId, gatewayUrl, serverPath }) => {
+    const result = await managerRcSpawn({
+      sessionId: adminSessionIdFor(accountId, senderId),
+      waChannel: { senderId, gatewayUrl, serverPath },
+      logContext: `channel=whatsapp-native senderId=${senderId}`
+    });
+    if ("error" in result) {
+      console.error(`[whatsapp-native] spawn-failed senderId=${senderId} error=${result.error} status=${result.status}`);
+    }
+  }
+});
+app44.route("/", waGateway.routes());
 var httpServer = serve({ fetch: app44.fetch, port, hostname });
 console.log(`${BRAND.productName} listening on http://${hostname}:${port}`);
 startAuthHealthHeartbeat();
@@ -16702,6 +17016,23 @@ init({
   platformRoot: resolve26(process.env.MAXY_PLATFORM_ROOT ?? join18(__dirname, "..")),
   accountConfig: bootAccountConfig,
   onMessage: async (msg) => {
+    if (process.env.MAXY_WA_NATIVE_CHANNEL === "1" && msg.agentType === "admin" && !msg.isOwnerMirror && msg.text) {
+      try {
+        void msg.composing().catch(() => {
+        });
+        await waGateway.handleInbound({
+          accountId: msg.accountId,
+          senderId: msg.senderPhone,
+          text: msg.text,
+          reply: msg.reply
+        });
+      } catch (err) {
+        console.error(
+          `[whatsapp-native] reject senderId=${msg.senderPhone} message=${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+      return;
+    }
     if ((msg.text || msg.mediaPath) && !msg.isOwnerMirror) {
       try {
         void msg.composing().catch(() => {

package/payload/platform/plugins/business-assistant/references/quote-engine.md

@@ -1,122 +0,0 @@
-# Priced-quote compute engine
-
-This reference is the **compute core** for a structured, priced quote: it turns a job (the items the
-owner selected, with their measurements or counts) into priced figures — line prices, group
-subtotals, and a final total — computed by **this owner's own pricing method**.
-
-It carries no items, no units, no rates, no margins, no overheads, no taxes, and no roll-up sequence.
-Every such value and rule is the owner's, captured as data. A trade pricing by the square metre, a
-caterer pricing by the head, and a printer pricing by per-unit break are all priced by the same
-approach — only their captured method differs.
-
-The compute engine itself is **not shipped**. You generate a small bespoke engine for this owner the
-first time they need a priced quote, and regenerate it whenever their business changes. The captured
-method is data the engine reads. Both persist in the owner's workspace and are re-run on demand.
-
-## When this path applies
-
-Use this for a **priced quote computed from the owner's method** — measured or counted work that has
-to be priced the way this owner prices it, then totalled. This is distinct from the simple
-photo-to-quote / chat-to-quote flow in `references/quoting.md`, which formats a quote the owner has
-already priced. If the owner has already worked out the numbers, stay in `quoting.md`. Come here when
-the numbers have to be **computed**.
-
-**Precondition:** a captured method for this owner must exist. Its *content* (the owner's items,
-rules, dials, roll-up, and past-job fixtures) is produced and maintained by the method-capture flow —
-Task 659 — which populates the method/job shape **this reference defines** below. If no captured method
-exists, capture it first; do not invent rates or rules here.
-
-## Where the engine and method live
-
-The agent runs in the owner's workspace (the spawn cwd, `$ACCOUNT_DIR`). Keep the engine and the
-captured method together under a `quoting/` subdirectory there, addressed by relative path:
-
-- the **method** — the owner's items, dials, and roll-up, as data;
-- the **engine** — the bespoke script that reads a method and a job and prices it;
-- the owner's **past jobs**, each with the figures they actually issued, used to verify the engine.
-
-These persist across sessions, are edited when the business changes, and are the engine's only inputs.
-Nothing about the owner's business lives in this reference or in the plugin.
-
-## The method shape (owner data)
-
-This section is the authoritative definition of the method/job shape; the method-capture flow (Task
-659) fills it with one owner's content. The method describes how this owner prices. For each
-**priceable item** it records:
-
-- what the item is (an identifier, a human label, a unit);
-- **how a quantity arises** — the item's own rule for turning a measurement into a quantity (for
-  example, an area from supplied dimensions, a length, a volume), or that the item carries **no
-  measurement rule** because it is counted or taken as a single unit. This is the item's *default*
-  quantity rule; a quantity entered on the job line always overrides it (see the job shape);
-- **how a line price is computed** — the owner's own rule for that item, in whatever form their
-  history shows it takes;
-- which **group** the line rolls into (the owner's own section headings);
-- whether the item is **standing-rule priced** (a rule fixes its price) or **judgement priced** (the
-  owner sets the price per job) — so the quote flow knows when it must ask the owner for a figure
-  rather than computing one.
-
-Alongside the items the method holds:
-
-- named **dials** — the owner's own scalars that their rules reference (a labour day-rate, a margin
-  multiplier, a percentage — whatever their method uses, named by them);
-- the **roll-up** — an ordered list of steps applied above the line items to reach the final total.
-  Each step names its rule, the prior figures it reads, and the label of the figure it produces. This
-  is whatever sequence the owner actually applies. It is **not** a fixed margin-then-overhead-then-tax
-  chain: an owner may apply an overhead, a contingency, a discount, a tax, or nothing, in their own
-  order. The engine implements exactly the step kinds this owner's roll-up uses, and no others.
-
-## The job shape (per quote)
-
-A job is the work selected for one quote: a list of lines, each naming an item and supplying **either**
-measurements **or** a directly-entered quantity, plus — for a judgement-priced item — the price the
-owner set for this line. The quantity source is decided per line by precedence: a quantity entered on
-the line is used as-is; otherwise the engine derives the quantity from the line's measurements via the
-item's measurement rule. An item with no measurement rule therefore requires an entered quantity (or
-its single-unit default). The job also carries the header the issued quote needs (who it is for, the
-address, the reference).
-
-## What the generated engine must do
-
-The engine reads one method and one job and produces the priced result. It must:
-
-1. **Resolve each line's quantity** — an entered quantity takes precedence; otherwise derive it from
-   the line's measurements via the item's measurement rule — and record which source was used.
-2. **Resolve each line's price** — by the item's own rule, or by the per-line figure the owner gave for
-   a judgement item — and record which was used.
-3. **Group** the priced lines under the owner's own headings.
-4. **Run the roll-up** steps in their defined order to reach the final total.
-5. **Emit observability** so a wrong figure is diagnosable from the log, not just the document: per
-   line, the resolved quantity and its source (measurement-derived vs entered) and the price rule
-   applied and its source (item rule vs per-line override); and each roll-up step with its result.
-6. **Reconcile** the sum of the group subtotals against the running line-item total and report it as an
-   explicit pass/fail — not a silent assumption.
-7. **Verify** on demand: given one of the owner's own past jobs, compare every computed figure
-   (line, group, final) against the figures the owner actually issued and report each as a match or
-   a mismatch.
-
-## Expressiveness — bounded by the owner's history
-
-Build the engine to support **exactly** the quantity, pricing, and roll-up forms the owner's own
-history exercises — discovered when their method was captured. Do not add quantity bases, price-rule
-forms, or roll-up step kinds the owner does not use. Unused generality is a liability: it is untested
-against their figures and invites a wrong quote later. If a new job needs a form the method has never
-expressed, that is a change to the captured method (and a re-verification), not a guess made here.
-
-## Acceptance — reproduction of the owner's own figures
-
-The engine is correct only when it **reproduces the owner's own past jobs** — line prices, group
-subtotals, and final totals — to the owner's own precision. The fixtures are that owner's
-history, supplied with their method; there are no built-in figures to test against. Reproducing their
-history, not parsing cleanly, is the signal that the engine prices the way they do. Verify on every
-generate and every method change; a reproduction failure blocks issuing a computed quote.
-
-## Boundaries
-
-- **Capturing and maintaining** the content of the method (items, rules, dials, roll-up, past-job
-  fixtures) is the method-capture flow — Task 659; it populates the shape this reference defines. This
-  reference consumes that method; it does not build it.
-- **Rendering** the priced result into the documents the owner issues (internal view, client
-  breakdown, branded quote) is Task 658. Those documents are printed to PDF through the existing
-  `browser-pdf-save` path (see `references/invoicing.md`); this compute reference produces only the
-  figures, not the documents.