@rubytech/create-maxy-code 0.1.265 → 0.1.266

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

@@ -1,94 +0,0 @@
-# Quote generation — output contract
-
-This is the **output half** of the engine-driven quote path. The engine (the operator's captured
-pricing method applied to a job) produces the figures; this contract turns those figures into the
-documents the operator issues, each rendered to PDF.
-
-It holds **no** business content. There are no fixed section names, no fixed wording, no fixed brand,
-and no fixed page layout here. What each document contains and how it looks is the operator's, held
-as their own data (their headings, their narrative, their charts, their logo, colours, contact and
-terms, their page size). The same contract serves any trade or service business by reading that
-operator's own document definitions.
-
-This is distinct from the lightweight WhatsApp quote in `references/quoting.md`. Use that one for a
-quick text quote. Use this one when the operator prices a job from a captured method and issues a set
-of reconciling documents.
-
-## What the engine hands you
-
-You render from the engine result. Read it as:
-
-- an ordered set of priced **groups** (the operator's own stages or categories);
-- each group an ordered set of **lines**; each line carries its quantity and the quantity's source
-  (measurement-derived or entered), its unit, its rate, its cost, and its sell;
-- each group's **subtotal**;
-- the operator's named **roll-up** steps — whatever sequence of adjustments and taxes they apply
-  above the line items, in order;
-- the **totals**: the client-visible subtotal and the final total.
-
-The engine guarantees the reconciliation invariant: the group subtotals carried through the roll-up
-equal the final total. You never recompute these figures — you display them.
-
-The engine itself, and how a line's quantity, rate, cost and sell are derived, are out of scope here
-(that is the compute core). This contract only reads the result.
-
-## The three documents
-
-The operator defines the content and styling of each; the **roles** are fixed, the **contents** are
-not. A document is **engine-driven**: a section or line appears **only where the job priced it**.
-
-| Role | Shows | Withholds | Filing scope |
-|---|---|---|---|
-| **Internal margin-bearing view** | every line's quantity and its source, unit, rate, cost and sell; each group subtotal; the full roll-up; the totals | nothing — this is the operator's own check on profitability before issuing | **admin-only** |
-| **Client breakdown** | how the price is composed, at the granularity the operator chooses: the client-facing amount per group or line, the roll-up steps the client sees, and the headline figure | any cost, margin, or internal rate figure (the operator's own unit rate, not a client-facing per-unit price) | client-facing (shared) |
-| **Client quote document** | the issued document in the operator's brand: their cover, their narrative or schedule, the client breakdown, the headline price, the acceptance block, and their standing terms | any cost, margin, or internal rate figure (the operator's own unit rate, not a client-facing per-unit price) | client-facing (shared) |
-
-The internal view exists so the operator can confirm the job is profitable before it goes out; it may
-expose cost and margin freely. The two client documents **never** surface a cost, margin, or
-internal-rate figure. A column or line that shows the price to the client is fine; a figure that
-reveals what the work cost the operator, or the markup applied, is a leak.
-
-### The margin boundary is the filing scope
-
-The leak boundary is structural, not a matter of remembering to omit a column. File each document by
-its scope, exactly as `references/document-management.md` defines:
-
-- the **internal margin-bearing view** goes to the **admin-only** customer folder
-  (`memory/admin/customers/{phone}/`), which the customer never receives;
-- the **client breakdown** and the **client quote** go to the customer-facing documents folder
-  (`memory/users/{phone}/documents/`).
-
-A document that carries cost or margin must never be written to the shared scope.
-
-## Print fidelity
-
-Each document becomes a PDF through the device's Chromium print pipeline, so the HTML must survive
-that pipeline. Start from the A4 print conventions already in `references/invoicing.md` and
-`references/document-management.md` — an `@page` size directive, `@media print` styles, and
-`page-break-inside: avoid` on blocks that must not split — and keep the operator's own page size on
-`@page` (their stationery may not be A4).
-
-A multi-page issued quote needs two things beyond what those siblings show; state them explicitly in
-the document:
-
-- page-level chrome — a running header or footer and page numbers — via `@page` margin boxes, never
-  absolutely-positioned elements that drift across pages;
-- `print-color-adjust: exact` on coloured fills, so the operator's brand fills survive print. The
-  renderer prints backgrounds, but make the intent explicit rather than relying on the default.
-
-## Producing the PDF
-
-Render the document as self-contained HTML (styles inline, images by absolute local path), then use
-the same path as every other business-assistant document:
-
-1. write the HTML to the document's filing-scope path;
-2. `browser-navigate` to it via a `file://` absolute URL;
-3. `browser-pdf-save` to an absolute `.pdf` path alongside the HTML;
-4. confirm a non-zero byte count from the `Saved PDF to <path> (<bytes>)` line before treating the PDF
-   as done.
-
-## Before you hand anything to the PDF tool
-
-Log, for the run: which document roles were produced, each one's page count, and the reconciliation —
-each document's displayed total against the engine total. If a document's total does not reconcile to
-the engine total, fail loudly and stop. Never ship a document whose figures disagree with the engine.

package/payload/platform/plugins/business-assistant/references/quoting.md

@@ -1,85 +0,0 @@
-# Quoting
-
-This reference is the **lightweight** quote path: read a handwritten or spoken quote, format it
-cleanly, and send it as a WhatsApp message (or a one-off PDF on request).
-
-When the operator prices a job from a captured pricing method and issues a set of documents that must
-reconcile to one engine total — an internal margin-bearing view, a client breakdown that withholds
-cost and margin, and a branded client quote — use `references/quote-generation.md` instead.
-
-## Where the operator's pricing comes from
-
-The operator's priceable items, quantity rules, pricing rules, and roll-up are not held here. They are
-captured and maintained by the `pricing-method` skill (invoke it via the Skill tool — see PLUGIN.md).
-That skill is the single source of the operator's own method; the quote flow consumes it. Because the
-method records which items are priced by a standing rule and which by per-job judgement, the quote flow
-applies the standing-rule items itself and asks the operator only about the judgement-priced lines.
-
-## Photo-to-Quote (Handwritten)
-
-1. Business owner sends a photo of their handwritten quote
-2. Read the handwriting using vision
-3. Format into a clean, professional quote:
-   - Customer name and address
-   - Description of work
-   - Labour cost (itemised if multiple tasks)
-   - Parts (if applicable — customers may buy parts directly)
-   - Materials markup (if set in memory)
-   - Total
-   - Validity period (default: 30 days)
-   - Payment terms
-4. Send back to business owner for approval: "Here's the formatted quote. Shall I send it to [customer]?"
-5. On approval → send to customer via WhatsApp
-
-## Quote from Conversation
-
-1. Business owner tells you the details verbally (text or voice)
-2. Format as above
-3. Confirm and send
-
-## Priced Quote (Computed from the Operator's Method)
-
-The two flows above format a quote the owner has **already priced** — they read the figures off a photo
-or out of a conversation. When the numbers instead have to be **computed** from the owner's own pricing
-method — measured or counted work priced item by item and rolled up to a total the way this owner
-prices — use `references/quote-engine.md`.
-
-That reference is the compute core: it generates a bespoke pricing engine from the owner's captured
-method and runs it on the job to produce line prices, group subtotals, and the final total,
-with an observability log and a check against the owner's own past quotes. It carries none of the
-owner's items, rates, or rules — those are the owner's captured data. Reach for it whenever the owner
-hands over measurements or quantities rather than a finished price. If there is no captured method yet,
-capture it first rather than inventing rates here.
-
-## Quote Formatting Template
-
-Quotes sent to customers should be clean, readable, and professional — but delivered as a WhatsApp message (not a PDF, unless the business owner requests one).
-
-```
-**Quote for [Customer Name]**
-[Business Name] — [Date]
-
-**Description of work:**
-[Itemised list of work to be done]
-
-**Cost breakdown:**
-- Labour: £[amount]
-- Parts: £[amount] (if applicable)
-- Materials: £[amount] (if applicable)
-- **Total: £[amount]**
-
-Valid for 30 days.
-Payment terms: [from memory, default "on completion"]
-
-Any questions, just reply to this message!
-```
-
-For formal PDF quotes, use the same workflow as invoicing — write HTML, `browser-navigate` to it, render with `browser-pdf-save`, then send as attachment. See `references/invoicing.md` for the PDF workflow.
-
-## Quote Follow-Up
-
-- If no response after configurable days (check memory for `quote_followup_days`, default 3): send a gentle nudge to the customer
-  > "Hi [customer]! Just following up on the quote I sent over for [work description]. Any questions or shall I go ahead and book it in?"
-- If no response after escalation period (check memory for `quote_escalate_days`, default 7): notify business owner and ask if they want to chase or drop it
-- Store outcome in memory: accepted / declined / no response
-- Update contact record status via `contact_update`

package/payload/platform/plugins/business-assistant/skills/pricing-method/SKILL.md

@@ -1,78 +0,0 @@
----
-name: pricing-method
-description: Use when an operator's own way of pricing jobs needs to become something the assistant can apply — onboarding a new business's pricing, building or editing their priceable items and rules by hand, re-learning their method from past quotes, or checking that the captured method reproduces their past quotes. Triggers include "set up my pricing", "learn how I quote", "add an item / change a rate", "my method's quotes don't match my past jobs", and any work that produces or maintains the method that the quote-generation flow consumes. Not for pricing or troubleshooting a single live quote — that is the quote-generation flow.
----
-
-# Pricing method
-
-This skill ends with a correct, machine-usable representation of **one operator's own** pricing
-method: the things they price (what each is, how it is quantified, how it is priced), the rules that
-roll line prices up to a total, and the documents they issue. The quote-generation flow consumes that
-method; this skill is the only place it is built and maintained.
-
-## Principle: the skill carries no business content
-
-This skill ships no item catalogue, no units, no rates, no margin, overhead, contingency or tax
-values, no roll-up formula, no document templates — **and no predetermined schema or data shape.** It
-is a procedure for eliciting and encoding an operator's *own* method. The same skill must onboard a
-trade that prices by the square metre, a caterer who prices per head in tiers, and a printer with
-per-unit price breaks — businesses with nothing in common. Everything that varies between businesses
-is captured as that operator's data, never written into this skill.
-
-The operator's structure is **discovered, not imposed.** Capture it faithfully wherever it diverges
-from any shape you might assume — an operator whose margin differs by category, who applies
-adjustments in an unusual order, who quantifies one item from a measurement and another by eye. If you
-find yourself forcing their method into a fixed template, the template is the defect. There is no
-canonical set of fields; there is only what *their* method actually contains.
-
-## Building, verifying, and maintaining the method
-
-Two paths build the method:
-
-- **Learn from history** — derive the method from the operator's own past pricing artifacts. See
-  [references/learning-from-history.md](references/learning-from-history.md).
-- **Define manually** — build or edit the method by hand for an operator with no usable history, or
-  making an adjustment. See [references/manual-definition.md](references/manual-definition.md).
-
-Two activities keep it correct:
-
-- **Verify against the operator's own outputs** — the method is accepted only when it reproduces that
-  operator's own past quotes to their own precision. See
-  [references/verification.md](references/verification.md).
-- **Maintain** — re-learning or editing preserves prior manual adjustments and re-verifies green. See
-  [references/maintenance.md](references/maintenance.md).
-
-**Onboarding** a new operator is a build path (learn from history, or define by hand) followed
-*always* by verification: the method is not onboarded until it reproduces their past jobs. A learned
-method and a hand-built method are the same kind of thing in the same captured form; nothing downstream
-should be able to tell which path produced an entry.
-
-## Standing rule vs per-job judgement
-
-For every priceable thing, the method records whether the operator prices it by a **standing rule**
-(the same rule applies every time — a rate, a tier, a formula they always use) or by **per-job
-judgement** (they decide the price afresh each job). This distinction is load-bearing: it is what lets
-the quote flow stay quiet about standing-rule items and ask the operator only about judgement-priced
-ones. Derive the classification from the operator's history — an item whose price moves
-unpredictably across past jobs is judgement-priced; one that follows a consistent rule is not — or
-take it from the operator directly when defining by hand.
-
-## Observability
-
-Under-capture that hides until it produces a wrong quote is the failure this skill exists to prevent.
-Two things are always visible:
-
-- **A capture log.** Every item, rule, and dial derived is logged with where it came from. Just as
-  important, every part of a source artifact that could **not** be confidently encoded — skipped,
-  ambiguous, or guessed — is logged as such, so gaps are seen at onboarding, not discovered later in a
-  wrong quote.
-- **A reconciliation report.** The standing check is reproduction against the operator's own history:
-  per past job, the **delta** between the reproduced figures and the operator's own, at line, group,
-  and final level — a delta, never a boolean. The verification pillar owns why and how
-  ([references/verification.md](references/verification.md)).
-
-## Scope
-
-This skill produces and maintains the method only. The compute that applies the method to a job, and
-the documents that present the result, are the quote-generation flow — separate work. This skill owns
-*what the operator's method is*; it does not own pricing a live job or rendering a quote.

package/payload/platform/plugins/business-assistant/skills/pricing-method/references/learning-from-history.md

@@ -1,51 +0,0 @@
-# Learning the method from history
-
-The operator has been pricing jobs for years. That method already exists — it lives in their past
-quotes, estimates, invoices, and spreadsheets. This pillar derives it from those artifacts so the
-assistant can apply the same method going forward. The source is whatever the operator actually used:
-a workbook, a folder of PDFs, photographed handwritten estimates, a price list. Work from what they
-have.
-
-## What a complete derivation captures
-
-From the operator's own artifacts, recover four things, and nothing the artifacts do not show:
-
-- **The priceable things.** Each distinct thing the operator charges for. Two lines that are the same
-  priced thing under different wording are one method entry, not two — collapse repeated instances of
-  the same thing across jobs into a single entry, and let the variation across those instances tell you
-  how the thing is quantified and priced.
-- **How each is quantified.** For each thing, how a job turns into a quantity. Some quantities are
-  derived from a measurement the operator takes (a length, an area, a volume, a weight); some are
-  counted directly (how many doors, heads, units); some are simply one of a thing. Read which it is
-  from how the past jobs got their numbers — do not assume a unit.
-- **How each is priced.** The rule that turns a quantity into a line price. It may be a rate per unit,
-  a tiered or banded price, a price that steps at break quantities, a fixed amount, or something else
-  entirely. Capture the form the operator's history actually shows; do not flatten everything into
-  "rate × quantity" if their numbers say otherwise.
-- **How lines roll up.** The sequence the operator applies above the line items to reach the total —
-  any markups, overheads, contingencies, discounts, and taxes, **in the order their arithmetic
-  reveals.** Do not assume a markup-then-overhead-then-tax chain; discover the operator's actual
-  sequence, including adjustments that apply to only part of the work.
-
-## Standing rule vs per-job judgement
-
-Classify each priceable thing as you derive it (the rule and why it matters are in
-[../SKILL.md](../SKILL.md)). On this path the signal is **variance across the operator's own jobs**: a
-price that follows a consistent rule from job to job is a standing rule; one that moves unpredictably
-is priced by judgement.
-
-## Faithfulness over tidiness
-
-The aim is the operator's method as it really is, including its irregularities. If their margin
-differs by category, capture that. If one adjustment applies before tax and another after, capture
-that. A clean, regular method that does **not** reproduce their past quotes is wrong; an irregular one
-that does is right. Reproduction is the test (see [verification.md](verification.md)).
-
-## Provenance and under-capture are recorded
-
-Every derived element carries where it came from — which artifact, which job. And every part of a
-source that could not be confidently encoded is logged as skipped, ambiguous, or guessed, rather than
-silently dropped or invented. A derivation that quietly omits a section the operator charges for will
-surface later as a quote that is wrong by exactly that section; logging the gap at onboarding is what
-prevents that. Under-capture you can see is a question to ask the operator; under-capture you cannot
-see is a future wrong quote.

package/payload/platform/plugins/business-assistant/skills/pricing-method/references/maintenance.md

@@ -1,32 +0,0 @@
-# Maintaining the method
-
-A pricing method is not set once. Rates change, items come and go, the operator refines how they
-charge, and a better history may arrive later that is worth re-learning from. Maintenance keeps the
-method correct across those changes without losing what was already established.
-
-## Re-learning preserves prior manual adjustments
-
-When the method is re-learned from history — because new artifacts arrived, or the first derivation
-was incomplete — the operator's prior manual adjustments are preserved, not overwritten. An operator
-who corrected a derived rate by hand, or added an item the artifacts missed, must not have that
-correction silently reverted by the next derivation. A re-learn that would drop a prior manual
-adjustment is a failure: surface the conflict to the operator and let them decide, rather than quietly
-choosing the freshly-derived value.
-
-This is why provenance matters (see [learning-from-history.md](learning-from-history.md)): an element
-the operator set by hand is distinguishable from one derived from an artifact, so a re-learn knows
-which it must not clobber.
-
-## Every change re-verifies
-
-Any maintenance pass — a re-learn, an added or retired item, a changed rate or roll-up step — is
-followed by re-running verification against the operator's own history (see
-[verification.md](verification.md)). The reconciliation must still be green to the operator's
-precision. A change that is recorded but breaks reproduction of a past job is not done; either the
-change is wrong, or a past fixture is no longer representative and the operator confirms which.
-
-## The outcome, not a storage scheme
-
-Maintenance is defined by two outcomes — prior manual adjustments survive, and reproduction stays
-green — not by any particular way of versioning or storing the method. How the method is held is the
-operator's data; what maintenance guarantees is preservation and re-verification.

package/payload/platform/plugins/business-assistant/skills/pricing-method/references/manual-definition.md

@@ -1,42 +0,0 @@
-# Defining and editing the method by hand
-
-Not every operator hands over a usable history, and every operator eventually changes how they price.
-This pillar builds or edits the method directly with the operator, by conversation, producing the same
-captured method that learning from history produces. A method built this way and a method learned from
-artifacts are indistinguishable to anything downstream — same kind of thing, same captured form.
-
-## What the operator must be able to express
-
-Building by hand means letting the operator state, in their own terms, the same four things a
-derivation recovers:
-
-- **A priceable thing** — something they charge for, named the way they name it.
-- **How it is quantified** — whether its quantity comes from a measurement they take, a count they
-  enter, or is simply one of a thing.
-- **How it is priced** — the rule that turns its quantity into a line price, in whatever form their
-  pricing takes (a rate, a tier, a price break, a fixed amount, or otherwise).
-- **How lines roll up** — the adjustments and taxes they apply above the lines, in the order they
-  apply them, and the dials those adjustments use (a markup percentage, a day rate, a tax rate).
-
-There is no fixed set of fields to fill and no form to complete. Capture what the operator's method
-contains; if their pricing for one thing needs something another thing's does not, the method holds
-both. Forcing every entry into the same template is the same defect here as it is when learning from
-history.
-
-## Standing rule vs per-job judgement
-
-Classify each thing here too (the rule and why it matters are in [../SKILL.md](../SKILL.md)). On this
-path the signal is simplest: **ask the operator directly** whether each thing is priced the same way
-every time or decided per job.
-
-## A hand-defined item is immediately quotable; a hand-edited rule takes effect
-
-The point of building by hand is that it works at once. A priceable thing the operator just defined is
-available to a quote with no further step, and a rule the operator just changed governs the next quote
-that uses it. An edit that is recorded but does not change what the next quote does is not an edit.
-
-## Editing is a first-class path, not a fallback
-
-Editing an existing method — adding a thing, retiring one, changing a rate or a roll-up step — runs
-through this pillar, and through [maintenance.md](maintenance.md) for preserving prior adjustments and
-re-verifying. A manual edit must survive a later re-learn from history; see maintenance.

package/payload/platform/plugins/business-assistant/skills/pricing-method/references/verification.md

@@ -1,37 +0,0 @@
-# Verifying the method against the operator's own outputs
-
-A captured method is a claim: "this is how the operator prices." The claim is accepted only when it
-reproduces that operator's own past quotes to their own precision. A method that parses cleanly but
-does not reproduce their history is not accepted. Reproduction of the operator's history is the
-acceptance signal — the only one.
-
-## The fixtures are the operator's own jobs
-
-Verification runs the captured method against the operator's past jobs and compares the result to what
-the operator actually quoted for those jobs. Those past jobs, with their own figures, are the
-fixtures. They are supplied per operator and are never built into this skill — this skill carries no
-business's numbers, so it carries no verification fixtures of its own. Pick jobs that exercise the
-range of the method: the items, the quantity forms, the pricing forms, and the roll-up the operator's
-work actually uses.
-
-## The report is a delta, never a boolean
-
-For each past job, report the difference between the reproduced figures and the operator's own, at
-three levels: each line, each group the operator subtotals, and the final total. "Matches / does not
-match" is not enough — it hides which line is wrong and by how much, which is exactly the information
-needed to find the error in the captured method. A method is accepted when every delta is within the
-operator's own precision; where a delta is outside it, the delta points at the entry to fix.
-
-## What a failing reproduction tells you
-
-A delta is a finding about the **method**, not a tolerance to widen. A wrong line total means that
-item's quantity rule or pricing rule was captured wrong. A right set of lines with a wrong final total
-means the roll-up sequence or a dial was captured wrong. Fix the captured method and re-run; do not
-adjust the acceptance threshold to make a wrong method pass.
-
-## Where the figures come from
-
-The compute that turns the captured method plus a job into reproduced figures, and the rendered
-documents those figures appear in, are the quote-generation flow — separate work that consumes the
-method this skill produces. This pillar owns the acceptance discipline: which jobs to reproduce, that
-the comparison is a per-level delta, and that reproduction to the operator's precision is the bar.