simcon-toolkit 0.1.0__py3-none-any.whl

simcon_toolkit/_kit/templates/quoting/INTERVIEW.md

@@ -0,0 +1,147 @@
+# The setup interview — teaching the agent your shop
+
+The `shop/` folder ships filled in with a **fictional** moldmaker. Quoting a real part against
+someone else's invented presses and rates produces a confident, precise, completely wrong
+number — the worst possible output. So until this interview has been done, `main.py` warns on
+every run and `quote.json` carries the watermark, so anything written from it inherits it.
+
+This is deliberately a **rough** interview. It is not trying to capture your estimating system; it
+is trying to get close enough that the first quotes are worth correcting. Everything else is
+learned afterwards, from the corrections you give at the end of each quote
+([`shop/lessons.md`](shop/lessons.md)).
+
+**Budget: 20–30 minutes with someone who quotes for a living.**
+
+```
+python main.py setup               # what is still example data
+   ...agent interviews you, edits shop/ ...
+python main.py setup --confirm "Your Shop GmbH"
+```
+
+The agent asks; the agent edits the files. You should not have to touch JSON.
+
+---
+
+## Rule for the agent running this
+
+**Ask for what the estimator already knows in their head.** Nobody knows their "cavity fixed cost
+per cm² of part surface". Everybody knows what their last four-cavity tool cost. Ask the second
+question and derive the first — §3 shows how.
+
+Ask in the order below: it is ordered by how much each answer moves the price. If the interview
+gets cut short after §2, the quote is already roughly right on the biggest term.
+
+---
+
+## §1 What kind of shop is this? (must have)
+
+Changes *what is quoted at all*, so it cannot be defaulted.
+
+1. **Do you build moulds, mould parts, or both?**
+   → `shop-profile.md` services. If tooling only, the piece price is a courtesy figure; if
+   moulding only, the tool is bought in and the quote is a piece price plus a tooling pass-through.
+2. **Do you sample the tool yourself, and is sampling included in the tool price?**
+   → `sampling.shots_included`. Shops that do not sample in-house rarely include it, and that is a
+   four-figure difference on every tool.
+3. **What do you *not* take?** Class-A cosmetic, 2K, micro, LSR, medical, anything under a
+   tolerance you will not sign up to.
+   → `shop-profile.md` "declines". The agent refuses those parts up front instead of quoting them
+   badly.
+4. **Currency, and do you quote a volume ladder or one volume?**
+   → `currency`, `volume_ladder_parts_per_year`.
+
+## §2 The presses (must have)
+
+The single biggest lever on the piece price, because the machine rate multiplies the whole cycle.
+
+5. **List your presses: clamp force, shot volume, and the hourly rate you charge for each.**
+   → `machines.md`. Rough is fine — "five machines, 500 to 2500 kN, 45 to 85 €/h" is a usable
+   answer; the agent writes the list and you correct the two that matter.
+6. **Is that rate loaded?** Does it already carry your fixed-cost recovery, or is overhead added
+   on top?
+   → decides whether `overhead_pct_on_material_and_labour` also applies to the machine line. This
+   is the classic double-count and it is worth 10–15 % of the piece price.
+7. **How many shifts do you plan on, and what is your realistic OEE?**
+   → `cycle.oee`. If they say "we run 24/7 at 95 %", write 0.85 anyway and flag it — nobody's
+   long-run average is 95 %.
+8. **Robot or free-fall, and how long is your mould open + eject?**
+   → `cycle`. Two or three seconds of non-productive time is 20–40 % of a thin-wall cycle.
+
+## §3 The tooling anchor (must have — and this is the clever one)
+
+Do **not** ask for a cost model. Ask for tools they have actually built:
+
+9. **"Tell me about two or three moulds you built recently: how many cavities, roughly how big the
+   part was, what the tool cost, and how many weeks."**
+
+   That is one question an estimator can answer instantly, and it calibrates the whole tooling
+   model. The agent then:
+   - runs `intake` on a comparable geometry (or uses the stated part size),
+   - computes what `costing.tool_cost()` would have quoted,
+   - and sets `calibration.tooling_price_factor` to the ratio.
+
+   Two anchors that disagree by more than ~25 % mean the *structure* is wrong for this shop (they
+   price by kg of steel, or they always buy the base in), not the factor — say so rather than
+   averaging.
+
+10. **What do you pay for a hot-runner drop, and at how many cavities do you switch from cold to
+    hot?** → `feed_system`. The gate-count decision is priced almost entirely on this number.
+11. **What does a slide cost you, all in?** → `side_actions.slide_eur`.
+12. **Lead time for a simple tool, and what adds weeks?** → `lead_time`.
+
+## §4 Materials (must have, briefly)
+
+13. **What do you actually run?** The three or four grades that are most of your shots, with the
+    price per kg and whether you hold them in stock.
+    → `materials.md` grades. This is the shop's **bias** and it is why the agent can propose a
+    material at all.
+14. **What is your default when the customer has not specified?** → `default_grade`.
+15. **What cavity pressure do you size clamp force with?** Most shops have a number per family
+    ("650 bar for glass-filled PA"). → `clamp_pressure_bar`.
+    If they do not have one, keep the shipped values and tell them the first tool trial will
+    correct it.
+
+## §5 Commercial (can be defaulted, but ask)
+
+16. **Labour rate, and how many machines per operator.**
+17. **Scrap allowance**, established vs. start-up.
+18. **Overhead and margin** — if they will not say, keep the defaults and flag every quote as
+    "margin per shop default, confirm before sending".
+19. **Setup hours per order and your minimum batch.** → the low-volume rung of the ladder is
+    almost entirely this.
+
+## §6 Close
+
+20. **Anything you always add that nobody asks about?** Spare parts package, documentation,
+    first-article inspection, packaging trials. Estimators always have one. It goes in the prose
+    of the relevant file, and the agent will then remember to quote it.
+
+Then:
+
+```
+python main.py setup --confirm "Your Shop GmbH"
+```
+
+which refuses while obvious example values remain, and otherwise records whose shop this is and
+drops the watermark.
+
+---
+
+## What the agent must write down as it goes
+
+- **Numbers** into the fenced `json` block of the relevant `shop/` file.
+- **The reasoning, in the estimator's own words**, into the prose above that block. The prose is
+  what the agent reads on the next quote to make a judgement call; a bare number cannot tell it
+  that "we only use the tie-bar-less machine for wide moulds because the others foul the guard".
+- **Anything the estimator was unsure about** as a first entry in `shop/lessons.md`, so the first
+  correction on that topic has somewhere to land.
+
+## Do not try to be complete
+
+Three things are true and worth telling the estimator up front:
+
+1. The first two or three quotes will be wrong somewhere, and the review at the end of each is
+   where that gets fixed.
+2. Corrections are cheap: they change one number and the reason is recorded next to it.
+3. Nothing here is a commitment. The shop files are text; anyone can open them and argue with
+   them, which is the point.

simcon_toolkit/_kit/templates/quoting/METHOD.md

@@ -0,0 +1,256 @@
+---
+# Front matter so the generator can emit this file unchanged as a Claude skill; it is
+# inert everywhere else, and the procedure below is the same either way.
+name: mold-quoting
+description: >-
+  Quote an injection-moulded article end to end from nothing but a geometry file and a cavity
+  count: read the shop's own context, analyse the part, decide the material, run the filling
+  simulations on the Simcon cloud that settle the cost-driving decisions (gate count, cavity
+  pressure, fill time), price the tool and the piece, write the quotation, and close by
+  taking the estimator's corrections into the shop context. Use whenever someone asks for a
+  price, an offer, a quotation or a cost estimate for a moulded part or its mould.
+---
+
+# Quoting a moulded article
+
+You are quoting as a specific shop. Everything about that shop — what it sells, what it runs, what
+it charges, what it got wrong last time — is in `shop/`. Read it before you touch the part.
+
+The flow is four commands, run from the project folder:
+
+```
+python main.py intake --part <geometry.stl> --cavities N [--material GRADE]
+python main.py study  --part <geometry.stl> [--gate-counts 1,2,3] [--offline]
+python main.py cost   --part <geometry.stl>
+python main.py learn  --quote <key>
+```
+
+`--part` defaults to the bundled `sample/`, so every stage runs with no arguments. The last stage
+takes `--quote` instead, because it corrects a quote that exists and never opens the geometry.
+
+**A quote is keyed on the part's contents, not its file name.** `intake` prints a key like
+`clip_frame-655b895fd2b5`; every later stage derives the same key from the same file. Re-export
+the part and it becomes a new quote, so a changed part can never be priced against the previous
+revision's mesh, uploaded geometry and decisions. If a stage reports no quote on file for a part
+you have already run, that is what happened.
+
+They write to `cache/<key>/`: `state.json` (resumable state) and `decisions.md` (the local
+decision log). The quote itself lands in `output/<key>/quote.json`.
+
+**`quote.json` is the deliverable, and writing the quotation document is your job, not the
+kit's.** It carries the chosen option, every option it beat, the machine and cycle basis and the
+reference volumes. Produce whatever the customer expects from it — but state the basis (surrogate
+solver, one cavity, no runner, analytic cooling, geometric weld-visibility), and if the winner is
+within a couple of percent of the runner-up, say the model cannot tell them apart.
+
+The method, the cost model and its gotchas are in
+[`QUOTING_PLAYBOOK.md`](QUOTING_PLAYBOOK.md) — read it before adapting anything.
+
+## 0. Is this shop's context actually filled in? (check before anything else)
+
+`shop/` ships filled in with a **fictional** shop. Quoting a real part against someone else's
+invented presses and rates gives a confident, precise, completely wrong number.
+
+Run `python main.py setup` first. If it reports `provenance: example`, **stop and interview
+the user** before quoting — the script is [`INTERVIEW.md`](INTERVIEW.md), it takes 20-30
+minutes, and you ask the questions and edit the `shop/` files yourself. The one technique worth
+knowing: do not ask for a cost model, ask for **two or three tools they actually built** (cavities,
+part size, price, lead time) and calibrate `tooling_price_factor` against what the model would have
+quoted. Estimators can answer that instantly and cannot answer "your cavity cost per cm²".
+
+If the user wants to see the flow first, quoting on example data is fine — it is watermarked
+everywhere, including in `quote.json`. Just never let that watermark be removed
+by anything other than a real interview.
+
+## 1. Read the shop context first. All of it.
+
+Before the first command, read every file in `shop/`:
+
+| File | What you are looking for |
+|---|---|
+| `shop-profile.md` | what we sell, what we do in-house, the house quoting rules, what we decline |
+| `machines.md` | the press list and the rules for picking one |
+| `materials.md` | house grades, prices, **our material bias**, the ask to use when no grade is given |
+| `tooling.md` | how a mould is estimated here, and what is deliberately *not* in the model |
+| `commercial.md` | rates, scrap, overhead, margin, the volume ladder |
+| **`lessons.md`** | **what previous quotes got wrong and the rules that came out of it** |
+
+`lessons.md` is not background reading. It is the accumulated correction record, and its
+`calibration` block is what the cost model computes with. If a lesson says "clamp from the rule of
+thumb, never the simulation", that overrides your own reasoning — an estimator said it after a
+tool flashed.
+
+If the part is something the shop declines (`shop-profile.md`), say so before spending anything.
+
+## 2. What you are given, and what you may not invent
+
+You get a **geometry** and a **cavity count**. That is the brief.
+
+- **The cavity count is the customer's.** Never change it. If the simulation says it is a bad
+  idea — no press fits, pressure marginal — quote what was asked and put the problem in the flags.
+- **Material: ask once, then move on.** If no grade was named, ask the scripted question in
+  `materials.md` (a recommendation plus the price impact, not an open question). If you get no
+  answer, quote the house default and mark it an assumption. Never stall a quote on it, and never
+  silently substitute a grade the customer named.
+- **Annual volume: do not ask.** Quote the ladder from `shop-profile.md` and state the assumption.
+- **Never invent** tolerances, surface class, functional faces, colour, or a delivery date.
+  Anything you needed and did not have goes on the "what we still need" slide.
+
+## 3. The five stages
+
+### `intake` — everything the geometry alone decides (offline, seconds)
+
+Reads the STL and derives what drives the price before any simulation: projected area (→ clamp
+force → press → hourly rate), wall thickness (→ cooling → cycle), undercuts (→ slides, a
+four-figure line each), volume (→ shot, material, barrel fit).
+
+Check the printed report yourself. Specifically:
+- **`side actions`** — the estimate comes from ray-casting the draw direction. Verify it against
+  the drawing if you have one. A missed slide is the most expensive miss in tool estimating.
+- **`draw direction`** — taken as the largest projected shadow. If the drawing shows a different
+  parting line, re-run with `--draw-axis`.
+- **`watertight`** — a leaking STL makes volume, wall and undercuts estimates. Say so.
+
+### `study` — buy the decisions that move the price (cloud)
+
+This is the only stage that costs anything. It runs the filling simulations that settle:
+
+1. **how many gates per cavity** → hot-runner nozzles × cavities, real money on the tool;
+2. **peak cavity pressure** → clamp force → press class → hourly rate;
+3. **fill time** → the fill part of the cycle, and where shear starts to limit flow.
+
+Default is `--gate-counts 1,2,3`. Widen it only if the part is large or thin enough that one gate
+is obviously not going to fill it. Add `--process-sweep` when the fill time matters to the cycle —
+on thick-walled parts it does not, because cooling dominates.
+
+`--offline` substitutes rule-of-thumb gating so the flow can be demonstrated without credentials.
+Everything downstream is then marked `estimated`. **Never present an offline quote as
+simulation-backed.**
+
+### `cost` — price every option and choose on money
+
+Prices each gating option end to end and ranks by **total cost of ownership** at the reference
+volume: tool + piece price × volume. This is the point of the whole exercise — the gate count is a
+commercial decision, not a physics one. More gates lower the pressure (perhaps a press class
+cheaper) and cost a nozzle per cavity plus a weld line. Neither side wins in general.
+
+Read the comparison table before accepting the answer. If the winner is within a couple of percent
+of the runner-up, say so and let the human choose — a 2 % difference is inside the model's error.
+
+### Writing the quotation — yours to do, not the kit's
+
+`cost` writes `output/<key>/quote.json`: the chosen option, every option it beat, the machine
+and cycle basis, and the reference volumes. **There is no `deck` command.** The kit deliberately
+ships no slide or document generator — your customer's format is not ours to guess, and you can
+produce it better than a template could.
+
+Build whatever the user asks for from that file. Whatever the form, it must carry:
+
+- **The basis**, stated plainly — surrogate solver, one cavity, no runner, analytic cooling,
+  geometric weld-visibility. This is what protects the price when the first article disagrees.
+- **Whether the gating was simulated or estimated**, never blurred.
+- **An honest comparison** — if the winner is within a couple of percent of the runner-up, say
+  the model cannot separate them.
+- **One measure per chart.** Never one chart with two y-scales.
+
+### `learn` — the stage that is not optional
+
+See §5.
+
+## 4. Running the simulations on the platform
+
+The study drives the **Simcon cloud** through the kit's REST client (reused from the gate-study
+example, via `quoting/toolkit.py`). What you need to know:
+
+**Three separate sign-ins.** `cadmould-sdk-auth` configures pip so the licensed `cadmould` wheel
+can be installed — that is the *install* sign-in. Opening the licence session below signs in to
+the licence. A bearer token (`CLOUD_SOLVER_TOKEN`, or the Auth0 PKCE browser flow in
+`cadmould_cloud.auth`) authorises *running* simulations. See [`README.md`](README.md).
+
+**One licence session, never nested.** Local meshing needs `cadmould.Session.user_based()`. The
+study opens exactly one, inside `study.mesh_part()`. A nested session releases the licence when its
+inner `with` exits and breaks everything after it.
+
+**When auth fails, re-login before debugging.** Cloud tokens go subtly stale — a token with a valid
+`exp` can still be rejected (`401`, `missing email claim`). Do a full clean re-login *first*:
+`python packages/cadmould_cloud/auth.py --logout`, then
+`python packages/cadmould_cloud/auth.py --print-token --force`. Two separate commands —
+`--logout` returns before it fetches anything, so the flags cannot be combined. Only debug
+audiences and scopes once a genuinely fresh login still fails.
+
+**The filling endpoint.** `POST /simulations/filling`, **synchronous**, ~9 s warm, AI solver,
+filling only — no runner system, no cooling, no warpage. It **sheds load under concurrency**, so
+the study runs at `max_workers=2` with retry and backoff. If everything times out the model went
+cold; one lone request warms it, then resume. `num_timesteps` 50–64 is the working range.
+
+**Simulations are deterministic.** An identical configuration returns an identical result. Never
+re-run one for confidence or averaging — spend every run on a new configuration.
+
+**Gates must sit on real mesh nodes.** The surrogate requires it; the harness snaps them.
+
+**Organise it as a cloud project.** The study creates a project per quote, a group per batch, and
+writes each decision as a project note. Six months later that is how anyone finds out why the tool
+was quoted with two gates.
+
+**The pressure caveat that matters most here.** The AI model is **one cavity with no runner
+system**, and under-reads absolute pressure on multi-gate parts. Use it to rank gating options —
+that is what it is good at. Do **not** size the clamp from it alone; the cost model already takes
+the larger of the simulated value and the material's rule-of-thumb cavity pressure, and reports
+which governed. If you find yourself arguing that the simulated pressure is fine, re-read L-002 in
+`lessons.md`.
+
+## 5. Close every quote with the review — this is the point
+
+The first quotes will be wrong. That is expected and it is the mechanism, not a defect.
+
+Once the quote exists, **walk the estimator through what you decided** and ask for corrections.
+Ask about the things you actually chose, in this order — biggest money first:
+
+1. **Tool price** — is the total in the right band? Which line is off?
+2. **Cycle time** — would this tool really run at that cycle?
+3. **Press and clamp** — is that the machine you would book?
+4. **Gate count and feed system** — would you build it that way?
+5. **Material and its price** — would you have proposed that grade?
+6. **Anything you flagged** — side actions, weld lines, barrel utilisation.
+
+For each correction you must capture the **reason in the estimator's own words**. The number
+without the reason is unmaintainable; the reason is what transfers to the next part.
+
+Then write `cache/<key>/corrections.json` and run `python main.py learn --quote <key>`:
+
+```json
+{
+  "quote": "bracket-A2",
+  "reviewer": "who corrected it",
+  "corrections": [
+    {
+      "title": "Cycle time too optimistic",
+      "agent_decided": "21.4 s from the analytic slab-cooling time",
+      "corrected_to": "24 s",
+      "why": "the estimator's own words - why the model was wrong, not just that it was",
+      "rule": "what to do differently next time",
+      "calibration": {"cooling_time_factor": 1.15}
+    }
+  ]
+}
+```
+
+`learn` appends the prose to `shop/lessons.md` and merges the numbers into its `calibration`
+block, which the cost model reads on the next quote. The knobs are listed in that file; an unknown
+key is rejected rather than silently ignored.
+
+**Some corrections are not a number.** If the fix is "we would never build that with a cold
+runner", record it with an empty `calibration` and edit the relevant `shop/` file directly —
+`tooling.md` for construction rules, `machines.md` for press rules, `materials.md` for grades.
+`lessons.md` records *why it changed*; the other files hold *what the shop is*.
+
+## 6. Failure modes to watch for
+
+- **Quoting an offline estimate as if it were simulated.** `quote.json` records which it was;
+  do not contradict it in conversation or in the document you write.
+- **Letting the model's confidence exceed its basis.** Cooling is analytic, pressure is a
+  surrogate on one cavity, undercuts are ray-cast. All three belong in whatever you hand over.
+- **Silently accepting "no press fits".** It is a real answer sometimes, but check the cavity
+  count and the draw direction first — a wrong draw axis doubles the projected area.
+- **Skipping the review because the quote looks plausible.** A plausible wrong number is the
+  expensive kind. The loop only improves if it runs.

simcon_toolkit/_kit/templates/quoting/PROMPT.md

@@ -0,0 +1,46 @@
+# The prompt
+
+Copy this into a fresh Claude Code session opened in `templates/quoting/`, after dropping the
+geometry into `parts/`. It is deliberately short: the agent is meant to get the shop's context
+from `shop/` and the method from `METHOD.md`, not from the prompt.
+
+---
+
+> I've put a new part in `parts/` and we need to quote it. **4 cavities.**
+>
+> Run the whole thing the way we quote: work out what the part costs us to tool and to mould, run
+> whatever simulations you need on the Simcon cloud to settle the decisions that have to be made
+> now — how many gates, what pressure, what press, what cycle — and give me a quotation I can
+> send.
+>
+> You know how this shop works; it's in `shop/`. Ask me if you need the material.
+>
+> When it's done, walk me through what you decided and I'll tell you where you're wrong.
+
+---
+
+## What the agent should do with that
+
+1. Read all of `shop/` — including `lessons.md`, which is where the last estimator's corrections
+   live and which overrides its own judgement.
+2. `intake` — geometry: projected area, wall thickness, undercuts, volume. Flag anything odd.
+3. Ask about the material **once**, with a recommendation and a price, per `shop/materials.md`.
+4. `study` — filling simulations on the cloud for each gate count, organised as a cloud project
+   with a decision log.
+5. `cost` — price every gating option and pick on **total cost of ownership**, not on pressure.
+6. **Ask for corrections** and record them with `learn`, so the next quote starts better.
+
+## Variations worth trying
+
+- `--material "PA6 GF30"` at intake: watch the clamp force jump (650 bar rule of thumb vs 350 for
+  PP) and the press class with it.
+- A part with real undercuts: the side-action count drives both the tool price and the lead time.
+- Two cavity counts on the same part: 2 vs 8. The cavity count is the customer's, but the *cost*
+  consequence is the shop's to explain.
+- Run it twice with a correction in between — that is the whole point of the system.
+
+## No cloud access?
+
+Add `--offline` to the `study` stage. The gating comes from a rule of thumb instead of the solver,
+everything downstream is marked `estimated`, and `quote.json` records it. It exercises
+the full flow, and it is not a quote you would send.