--- title: LFCS Bid System — Plan created: 2026-05-03 created_by: claude-code-coo (plan-mode pass) status: approved-phase-0-1-with-refinements # Phase 2 gated, Phase 3 as scoped (per HQ gap analysis 2026-05-03) related: - "[[PM-Workflow-Pattern]]" - "[[2602 - Dec Projects - Munmorah Bridge/00-Bid-Prep]]" - "[[Hermes-as-COO-Architecture-2026-05-03]]" --- # LFCS Bid System — Plan > Plan-mode design pass. No code, no edits anywhere except this file. HQ runs gap analysis when Rocky opens the next HQ session. Iterate from there. > Authored by claude-code-coo on 2026-05-03 evening, after the one-time HQ scaffold of 2602 Munmorah Bridge proved the workflow works end-to-end on a real bid. This plan turns that one-shot proof into a repeatable system across ~10–11 LFCS jobs. --- ## 1. Read summary Read in this order, key takeaways from each: 1. **`HQ-Vault/_System/CLAUDE.md`** — AI Team Protocol. Three layers (Strategy / PM / Ops). One agent per project folder at a time. Append-only on `_Log.md`, dailies, `_AgentLog/`. Hard rules: no deletions, no body edits without read, no new top-level folders, no sensitive data, no content invention. Commit format: `{agent}: {short summary}`. 2. **`PM-Workflow-Pattern.md`** — the workflow scaffolded tonight. 13-step Stage-A bid prep, Stage-B intake, Stage-C scaling decision (re-evaluate Airtable at 5 jobs in). Already flagged the gaps this plan must fill: vision-pass on drawings, BOQ↔drawings cross-check, pricing-history lookup, subbie performance log. 3. **`folder-spec.md`** — canonical 11-section per-job folder. Naming rules (hyphens, dates, versions, no spaces). "Where does it go" cheat-sheet. OpsMan files at moment of receipt; refuses ambiguous filing; normalises filenames. 4. **`rate-card.md`** — labour rates: $85/hr ord, $105/hr OT (h9–10), $120/hr DT (h10+). Saturday + Sunday + night tiers. **Open: public holidays, night-shift definition, travel time, plant rates, materials mark-up.** Docket sign-off non-negotiable; no signed docket = no invoice line. 5. **`2602 Munmorah Bridge` folder (PoC)** — `00-brief.md` (job metadata + quantities-at-a-glance + risks + dates), `00-Bid-Prep.md` (full analysis), `Pre-Call-Questions-2026-05-05.md` (18 categories, answer slots), `Inclusions-Exclusions.md` (drafted from text extract + BOQ), `Drawing-Index.md` (per-drawing structured YAML + tags + cross-references + discrepancy table). The Drawing-Index is the queryable bit Robert asked for. Built from text extraction only — vision-pass still owed by Rocky tomorrow. 6. **`hermes-2026-04-30-self-audit.md`** — Hermes already has nine LFCS skills (docket-check, eod-summary, job-tracker, pre-pour-check, rfi-status, timesheet, client-correspondence, tool-tracker, whatsapp-bridge-setup). Cron jobs running for AM look-ahead, EOD summary, weekly programme. WhatsApp bridge live on :3500. **Hermes runs on MiniMax-M2.7** — cheap but quality ceiling on judgment-heavy reasoning. No `ANTHROPIC_API_KEY` on VPS yet. 7. **`Hermes-as-COO-Architecture-2026-05-03.md`** — HQ's draft proposal. Hermes-as-dispatcher: triages cheap with MiniMax, dispatches heavy work to Claude Code CLI on the VPS via `claude -p ... --output-format json --allowedTools ...`. Cron tick every 5 min, file-locked, 10-min hard timeout, escalation via Telegram. Eight safety-rail classes. Implementation cost ~5 hours of focused VPS work. **This proposal directly informs how the LFCS bid system's heavy work surfaces — the dispatcher pattern is the right shape.** Cross-reading note: the COO architecture and the LFCS bid system are complementary, not overlapping. COO is the standing daemon for ops requests; the LFCS bid system is a domain-specific workflow that COO can dispatch into. Skills in the LFCS catalog can be invoked by either Cowork (synchronous, Rocky-driven) or Hermes-COO (autonomous, dispatched to CC CLI). --- ## 2. System architecture ``` ┌─────────────────────────────────────────────────────────────────┐ │ ROCKY (drops files, makes calls, signs) │ └──────┬─────────────────────────────────────┬────────────────────┘ │ │ │ drop drawings + BOQ │ Telegram on-site ▼ ▼ ┌──────────────────────┐ ┌──────────────────────────┐ │ cowork-lfcs (desktop)│ │ Hermes (VPS daemon) │ │ Cowork project │ │ Telegram + voice + cron │ │ - drag-drop UI │ │ - dictation, photos │ │ - file access │ │ - EOD summary │ │ - Read tool │ │ - RFI status, dockets │ │ - synchronous chat │ │ - dispatch heavy jobs │ └────┬─────────────────┘ └────────┬─────────────────┘ │ │ │ skill invoke │ skill invoke (cron / Telegram) ▼ ▼ ┌─────────────────────────────────────────────────────────────────┐ │ LFCS SKILL CATALOG │ │ HQ-Vault/11_OpsMan_LFCS/Operations/skills/ │ │ (canonical source — version-controlled in vault) │ │ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │ │ │ Bid prep │ │ Ongoing │ │ Cross-project │ │ │ │ - scaffold │ │ - rfi-draft │ │ - pricing-hx │ │ │ │ - extract-txt │ │ - vo-draft │ │ - postmortem │ │ │ │ - extract-vis │ │ - defects │ │ - tracker │ │ │ │ - boq-parse │ │ - subby-brief │ │ │ │ │ │ - cross-check │ │ - programme │ │ │ │ │ │ - bid-prep │ │ - prog-claim │ │ │ │ │ │ - precall-q │ │ │ │ │ │ │ │ - incl-excl │ │ │ │ │ │ │ │ - pricing-est │ │ │ │ │ │ │ │ - bid-vs-qs │ │ │ │ │ │ │ └───────────────┘ └───────────────┘ └───────────────┘ │ └──────┬──────────────────────────────────────────────────────────┘ │ heavy work (vision, batch parse, pricing, comparison) ▼ ┌─────────────────────────────────────────────────────────────────┐ │ CLAUDE CODE CLI (dispatched by cowork-lfcs OR hermes-coo) │ │ - pdftoppm + Claude vision API for drawing extraction │ │ - Python: openpyxl for BOQ parse, sqlite3 for pricing-hx │ │ - bounded --allowedTools per dispatch │ └──────┬──────────────────────────────────────────────────────────┘ │ writes to vault ▼ ┌─────────────────────────────────────────────────────────────────┐ │ HQ-VAULT (single source of truth, git-synced VPS ↔ desktop) │ │ - per-job folder per folder-spec.md │ │ - per-job Drawing-Index.md (queryable YAML) │ │ - per-job Pricing-Working-{date}.xlsx + priced-boq.md │ │ - cross-job pricing-history.md (MVP) → pricing.sqlite (v2) │ │ - per-job QS-Comparison-{date}.md (after QS shares) │ └─────────────────────────────────────────────────────────────────┘ ``` **One paragraph:** Skills are the canonical units. They live in the vault (`Operations/skills/`) so they're version-controlled and visible to all surfaces. Three execution surfaces invoke them: cowork-lfcs (Rocky's synchronous desktop driver, primary for bid prep + drawing review + drag-drop), Hermes (autonomous VPS daemon for on-site capture + cron + dispatched ops), and Claude Code CLI (the heavy-lifting executor for vision, batch parse, pricing, and any task wanting Claude-grade reasoning + tool use). Heavy work always lands in CC CLI to keep MiniMax cost-floor for triage and Claude-quality for judgment. Output writes back to the vault under the canonical folder structure; every write is a git commit via auto-sync, every session logs to dailies + project `_Log.md`. --- ## 3. Skill inventory Naming convention: `lfcs-{verb}-{noun}` (matches existing Hermes catalog). Each skill has a `SKILL.md` per the chat-bootstrap pattern. ### Bid prep skills (the proof-of-concept stack — refine on every bid) | Skill | Purpose | Inputs | Outputs | Deps | MVP / v2 | Surface | |---|---|---|---|---|---|---| | `lfcs-job-scaffold` | Create the canonical 11-section folder + frontmatter | `job_no`, `client`, `site`, `bid_due` | Folder tree + `00-brief.md` + `README.md` | folder-spec.md | **MVP** | cowork-lfcs | | `lfcs-drawing-extract-text` | Text extract every PDF in `03a` + tag per drawing | drawings folder | `Drawing-Index.md` (per-drawing YAML blocks) | none | **MVP** (already proven on 2602) | cowork-lfcs / CC CLI | | `lfcs-drawing-extract-vision` | Vision-pass per page for drawn geometry text extraction misses | drawings folder, `Drawing-Index.md` | Updates `Drawing-Index.md` with vision-only fields (dimensions, hatching, section markers, detail bubbles) | pdftoppm, Claude vision API | **MVP** | CC CLI (dispatched) | | `lfcs-boq-parse` | Parse xlsx BOQ into canonical line schema | `02b/*.xlsx` | `boq-normalised.json` + quantities-at-a-glance table for `00-brief.md` | openpyxl | **MVP** | cowork-lfcs / CC CLI | | `lfcs-boq-cross-check` | Flag BOQ↔drawing misalignment | `boq-normalised.json`, `Drawing-Index.md` | `cross-check.md` (BOQ items w/o drawing ref + drawn elements w/o BOQ line) | extract-text + boq-parse | **MVP** | cowork-lfcs | | `lfcs-bid-prep-doc` | Generate `00-Bid-Prep.md` from extracts | `00-brief.md`, `Drawing-Index.md`, `boq-normalised.json` | `00-Bid-Prep.md` | extract + parse | **MVP** | cowork-lfcs | | `lfcs-precall-questions` | Generate Pre-Call-Questions from gaps + risks | `00-Bid-Prep.md`, `cross-check.md`, BOQ | `Pre-Call-Questions-{date}.md` | bid-prep-doc | **MVP** | cowork-lfcs | | `lfcs-incl-excl-draft` | Draft Inclusions/Exclusions/Qualifications | `00-Bid-Prep.md`, `boq-normalised.json` | `Inclusions-Exclusions.md` | bid-prep-doc | **MVP** | cowork-lfcs | | `lfcs-pricing-estimator` | Apply LFCS rates + history to BOQ quantities | `boq-normalised.json`, rate-card, pricing-history | `Pricing-Working-{date}.xlsx` + `priced-boq.md` | rate-card.md, pricing-history | **v2** (MVP = manual rates) | cowork-lfcs / CC CLI | | `lfcs-bid-vs-qs-compare` | Line-by-line diff LFCS estimate vs QS-shared price | `priced-boq.md`, QS price (paste / xlsx) | `QS-Comparison-{date}.md` + flywheel ingest | pricing-estimator | **v2** | cowork-lfcs | ### Ongoing project skills (post-award — bigger feature set, lower bid-week urgency) | Skill | Purpose | Inputs | Outputs | Deps | MVP / v2 | Surface | |---|---|---|---|---|---|---| | `lfcs-rfi-drafter` | Draft RFI from question + drawing context | question text, drawing ref | `06b/RFI-{NNN}.md` + register update | drawing-index | **v2** | cowork-lfcs | | `lfcs-variation-drafter` | Draft VO claim from change description + rate-card | change desc, BOQ ref, photos | `08/VO-{NNN}.md` | rate-card | **v2** | cowork-lfcs | | `lfcs-defects-register` | Maintain defects register at PC | defect entries (Telegram or chat) | `11a/Defects-Register.md` | none | **v2** | **Hermes** = input capture (Telegram dictation, photos); **cowork-lfcs** = artefact authoring | | `lfcs-subby-brief` | Draft subby brief from job scope + section | job, scope section | brief PDF/MD | bid-prep-doc | **v2** | cowork-lfcs | | `lfcs-programme-drafter` | Draft programme bar-chart from sequence + durations | sequence, durations | programme.md (Mermaid Gantt) or xlsx | none | **v2** | cowork-lfcs | | `lfcs-progress-claim` | Build progress claim from job tracker + dockets | job-tracker.xlsx, dockets folder | `09a/PC-{NN}.md` | job-tracker | **v2** | **Hermes** = input capture (dockets, hours); **cowork-lfcs** = artefact authoring | ### Cross-project skills | Skill | Purpose | Inputs | Outputs | Deps | MVP / v2 | Surface | |---|---|---|---|---|---|---| | `lfcs-pricing-history-lookup` | Query past priced BOQs by element / material / supplier | query string | matching lines + summary stats | pricing-history store, element-taxonomy | **MVP** | **cowork-lfcs** primary (judgment work); Hermes only for simple "show me last N jobs that touched X" lookups | | `lfcs-bid-postmortem` | Capture deltas after award/loss + feed flywheel | job folder, outcome | `Postmortem-{date}.md` + flywheel ingest | bid-vs-qs-compare | **v2** | cowork-lfcs | | `lfcs-job-tracker-maint` | Update job tracker as work happens | dockets, hours, costs | updated job-tracker.xlsx | folder-spec | **already exists in Hermes catalog** | Hermes | ### Tender / portfolio skills (added 2026-05-03 per HQ gap analysis) | Skill | Purpose | Inputs | Outputs | Deps | MVP / v2 | Surface | |---|---|---|---|---|---|---| | `lfcs-site-recon` | Pre-bid site visit capture (photos, conditions checklist, access notes, services observed) | photos, voice notes, geotag | `Site-Recon-{date}.md` in job folder + photo file in `07b` | folder-spec | **v2** | **Hermes** (Telegram on-site capture) → cowork-lfcs (markdown synth) | | `lfcs-subby-quote-intake` | Capture subby quotes against scope items (sub-rate feeds LFCS unit rate) | subby quote (PDF/email/xlsx), scope ref | `02c - Subby-Quotes/{trade}-{subby}-{date}.md` + pricing-history `cost_basis` field | folder-spec, pricing-history | **v2** | cowork-lfcs | | `lfcs-tender-correspondence` | Manage email thread with QS during bid week (file → reference → respond) | inbox thread | exported PDFs in `06a` + summary one-liner in 00-Bid-Prep open items | folder-spec | **v2** | cowork-lfcs | | `lfcs-tender-tracker` | Portfolio-level bid status dashboard (submitted / awaiting / won / lost / withdrawn) | all `Jobs/Upcoming/` folders' frontmatter | `lfcs-standards/Tender-Tracker.md` (sortable table) | folder-spec | **v2** (needed at 5+ live bids) | cowork-lfcs / Hermes | | `lfcs-contract-review` | Post-award diff: awarded contract vs submitted bid. Catches scope drift before sign. | awarded contract PDF, submitted Inclusions-Exclusions.md, priced BOQ | `Contract-Review-{date}.md` (deltas + flags) | bid-prep + incl-excl | **v2** | cowork-lfcs | | `lfcs-boq-generator` | Generate BOQ from drawings + scope brief when no BOQ provided by QS | drawings folder, scope brief | draft BOQ.xlsx + boq-normalised.json | extract-text + extract-vision | **v2** | cowork-lfcs / CC CLI | ### Already-existing Hermes skills (keep as-is) `lfcs-docket-check`, `lfcs-eod-summary`, `lfcs-job-tracker`, `lfcs-pre-pour-check`, `lfcs-rfi-status`, `timesheet`, `lfcs-client-correspondence`, `lfcs-tool-tracker`. These cover the Telegram/voice/cron layer — no overlap with the bid-prep skills above. ### Skill count summary - **MVP (build this week / month):** 9 skills (`job-scaffold`, `drawing-extract-text`, `drawing-extract-vision`, `boq-parse`, `boq-cross-check`, `bid-prep-doc`, `precall-questions`, `incl-excl-draft`, `pricing-history-lookup`) - **v2 (build after Phase-2 trigger gate hits):** 14 skills (`pricing-estimator`, `bid-vs-qs-compare`, `rfi-drafter`, `variation-drafter`, `defects-register`, `subby-brief`, `programme-drafter`, `progress-claim`, `bid-postmortem`, `site-recon`, `subby-quote-intake`, `tender-correspondence`, `tender-tracker`, `contract-review`, `boq-generator`) - **Total catalog:** 23 skills + existing Hermes Telegram/voice/cron layer (9 skills). --- ## 4. Drawing extraction pipeline — concrete recommendation **Problem:** PDF text extraction (what HQ did tonight) misses drawn geometry, dimensions outside text labels, hatching, section markers, detail bubbles, graphical clashes. Vision-pass is mandatory for trustworthy quantities. **Three options evaluated:** | Option | How | Speed/page | Cost/page | Quality | Ops complexity | |---|---|---|---|---|---| | A. `pdftoppm` → PNG → Claude Vision API direct (Sonnet 4.6) | Python wrapper script invoked via skill, batches pages, single API call per page with structured-output prompt | ~20–40s | ~$0.04 (Sonnet, 1 page A1 @ 200 DPI = ~1500 input tokens img + ~800 output) | High — best vision among major models per recent benchmarks | Low. `pdftoppm` is on every Linux box (poppler-utils); already on the VPS. One Python file. | | B. `pdftoppm` → PNG → cowork-lfcs Read tool (one-by-one) | Manual: drop PNGs into Cowork, ask it to read each | ~30s but interactive | $0 (subscription) | High but Rocky-blocking | Zero new code. But slow + unbatched. | | C. `pdftoppm` → PNG → OpenAI gpt-4o (vision) | OPENAI_API_KEY already on VPS (Hermes uses it for aux vision) | ~15–25s | ~$0.02 | Medium — gpt-4o weaker than Claude Sonnet on dense engineering drawings (Hermes audit notes MiniMax vision was broken; gpt-4o-mini is "auxiliary") | Lower setup (key already there). Quality risk on bridge-density detail. | **Recommendation: Option A — `pdftoppm` + Claude Vision API direct, packaged as a CC-CLI-dispatched skill (`lfcs-drawing-extract-vision`).** Why: - Best quality for the cost. Bridge drawings are dense; recall matters more than per-page price. ~$0.30/job at typical 7-page drawing sets. - Batchable. One skill invocation processes a folder; no Rocky-in-the-loop. Cowork-lfcs hands the folder to CC CLI; CC CLI shells `pdftoppm`, loops pages, hits API, writes back to `Drawing-Index.md` under `vision_findings:` block per drawing. Total round-trip ~3–5 min for 7 pages. - Reuses the dispatcher pattern from the COO architecture: cheap triage (Cowork or MiniMax), heavy work (vision API) on dispatched CC CLI session. - Augments rather than replaces text extraction. Workflow: text-pass first (fast, cheap, 90% of structured fields), vision-pass second (catches the geometric remainder), both write to the same `Drawing-Index.md` with separate sub-blocks per drawing so the source is always traceable. **Concrete pipeline (MVP):** ``` 1. pdftoppm -r 200 input.pdf out_prefix # → out_prefix-1.png, -2.png, ... 2. for each PNG: base64-encode → POST anthropic.messages model: claude-sonnet-4-6 prompt: "Extract from this engineering drawing in JSON: geometry_dimensions, materials_called_out, section_markers, detail_bubbles, drawn_clashes_with_text_labels, ..." 3. Parse JSON, append `vision_findings:` block per drawing in Drawing-Index.md 4. Append `tags:` extension lines for new tags found via vision ``` **Open question — Phase 0 alternative for Wednesday:** for the 2602 Munmorah bid, Rocky can run `pdftoppm` on his desktop tomorrow and either drag the PNGs into Cowork (Option B, no new code) or invoke local Claude Code CLI with the PNGs and a structured prompt. Either delivers vision findings into `Drawing-Index.md` before Tuesday's QS call. The skilled, repeatable version (Option A) lands in Phase 1 for the next bid. --- ## 5. Pricing engine + data model > **2026-05-04 update — Airtable adoption pivot.** Original Section 5 (below) deferred Airtable to ~5-job decision point. Rocky's call 2026-05-04 PM overrides this. Rationale: (1) parallel Cowork-vs-Claude-Code A/B test (see [[AB-Test-Tracker]]) needs a queryable shared store; (2) Drawing Elements queryable layer per the FromScratch construction-AI video pattern needs Airtable now; (3) Rocky validated cost is acceptable for current scale. Constraint preserved: vault markdown remains source of truth, Airtable derives from it via the new `lfcs-airtable-sync` skill. Per-line markdown in `pricing-history/` continues for the QS-feedback flywheel — Airtable mirrors it. New `LFCS-Operations` base (id `appE43UvTyARe5oJs`) has 11 tables — see `_System/CLAUDE.md` "Airtable as canonical query/index layer" section + `11_OpsMan_LFCS/_Brain/CLAUDE.md` schema cheatsheet for IDs/fields. **Append-only on this section: original deferred-Airtable text below stays for historical context.** --- **MVP (build this month, target ~10 jobs):** **Markdown files with YAML frontmatter, one file per priced BOQ line.** Why markdown for MVP: - Zero new dependency. Greppable. Obsidian-searchable. Works with the existing append-only protocol. - Every priced BOQ already lives in the per-job folder. We layer a thin export step that writes per-line markdown to a central `pricing-history/` folder with backlinks to the source job. - Frontmatter schema is the contract — easy to migrate to SQLite later by parsing frontmatter. **Concrete schema (per-line markdown file):** ```markdown --- job_no: 2602 client: Dec Projects job_type: bridge-frp-package boq_section: 6.4.1 element: place-finish-concrete # MUST match controlled vocab in element-taxonomy.md sub_element: abutment # MUST match taxonomy sub_elements material: concrete-50mpa unit: m3 quantity: 53.064 unit_rate_aud: 380 # what LFCS priced qs_unit_rate_aud: 365 # what QS came back with (null if not shared) qs_share_status: shared-verbal # shared-verbal | shared-written | declined-to-share | not-asked delta_pct: -3.95 # auto-calc; null if qs_share_status != shared-* date_priced: 2026-05-06 outcome: submitted # submitted / awarded / lost / withdrawn location: NSW-Central-Coast shift: day complexity_factors: # multi-tag — informs lookups + future estimator weighting - height-over-3m - salt-water-proximity - restricted-access - heavy-reo-density-287kgm3 notes: QS used cheaper Boral mix; flag for next bid. source_job: "[[2602 - Dec Projects - Munmorah Bridge/00-Bid-Prep]]" --- [free-text paragraph optional — only if a non-obvious assumption drove the rate] ``` Path: `HQ-Vault/11_OpsMan_LFCS/Operations/lfcs-standards/pricing-history/{job_no}-{boq_section}-{slug}.md` **Schema preconditions (per HQ gap analysis Section 5):** - `element` and `sub_element` MUST validate against `lfcs-standards/element-taxonomy.md` controlled vocabulary. Free-text drift breaks aggregate queries at scale. - `complexity_factors` enables apples-to-apples lookups: "200mm L-wall easy-access" vs "200mm L-wall restricted-access" return different distributions. - `qs_share_status` distinguishes "no QS data" from "QS data = same as ours" — critical for honest history. Lookup is a `lfcs-pricing-history-lookup` skill that does either (a) Obsidian dataview query, (b) ripgrep on YAML keys, or (c) a 30-line Python script that walks the folder and returns matching lines. All three are MVP-acceptable. **v2 (~50 jobs, decision point ≈ 2026-08 per `PM-Workflow-Pattern.md`):** **SQLite single-file db, generated from the markdown frontmatter via sync script.** Why SQLite for v2: - Single file, version-controllable in git (binary but small for ~10k rows), zero infrastructure. - Real queries (`SELECT AVG(unit_rate_aud) FROM lines WHERE element='place-finish-concrete' AND date_priced > '2026-01-01'`). - Markdown remains source of truth; SQLite is a derived index. One-way sync, rebuild from scratch on demand. - No subscription cost. No external dependency. Works identically on desktop + VPS. **Airtable: defer.** Recommend NOT for MVP and probably not even for v2 unless office actually needs the multi-user UI. ~$20/user/month per seat × Rocky + other PM + Hermes write-access = ongoing cost, external dependency, sync complexity, and the markdown layer already gives Cowork/Obsidian-grade search. Re-evaluate at the 2026-08 decision point in `PM-Workflow-Pattern.md` Stage C. **Open question (Rocky decision):** does Robert want a UI he can poke at independently of the vault? If yes, Airtable becomes the "viewing surface" only and markdown remains the writeable source — that's a defensible split. Otherwise skip. --- ## 6. QS-feedback flywheel — schema **Trigger:** QS shares their expected line prices (or the awarded sub-rates if LFCS wins). **Capture file:** `02 - Scope and Pricing/02d - QS-Comparison/QS-Comparison-{date}.md` (new sub-folder; one-time addition to `folder-spec.md` — flag for HQ approval). **Schema:** ```markdown --- job_no: 2602 qs_provided_date: 2026-05-05 qs_provided_format: verbal-on-call # verbal / email / xlsx / pdf lfcs_estimate_total_aud: 482000 qs_total_aud: 451000 delta_total_pct: -6.4 classification: under # under / over / on-target related: - "[[priced-boq]]" - "[[Pre-Call-Questions-2026-05-05]]" --- # QS Comparison — Munmorah Bridge — 2026-05-05 ## Per-line comparison | BOQ # | Element | Unit | Qty | LFCS rate | QS rate | Delta % | Notes / why | |---|---|---|---|---|---|---|---| | 6.4.1 | Place + finish concrete — abutments | m³ | 53.064 | $380 | $365 | -3.95 | QS used cheaper Boral mix; flag for next bid | | 6.4.2 | Place + finish concrete — wingwalls | m³ | 44.44 | $410 | $370 | -9.76 | LFCS over-priced for height/access; revise | | 7.2.3.1 | Pour + finish bridge deck concrete | m³ | 101.62 | $440 | $480 | +9.09 | LFCS under-priced; deck pour complexity wasn't reflected. Worth keeping the win if awarded — but flag | | ... | | | | | | | | ## Patterns observed (one-paragraph) LFCS consistently 5–10% high on substructure, 5–10% low on superstructure. Hypothesis: rate-card baseline doesn't account for height/access factor on wingwalls and undercounts deck-pour complexity. **Action:** add `complexity_factor` field to pricing-history schema for next bid. ## Flywheel ingest Every line above flows into `pricing-history/{job}-{boq}-{slug}.md` with `qs_unit_rate_aud` + `delta_pct` filled. Next bid's `lfcs-pricing-estimator` queries history for matching `element` + `material` + `location` + `shift` and reports: "last 5 priced abutment-concrete jobs averaged $367/m³ delivered, you've priced $380. QS in past landed $360–$370 — consider $370." ``` **Lookup query for "last 5 jobs that had a 200mm RC L-wall":** MVP (markdown + ripgrep): `rg -l "element: rc-l-wall" pricing-history/ | xargs head -20 | grep -E "(unit_rate_aud|qs_unit_rate_aud|date_priced)"` → top-5 most recent. v2 (SQLite): `SELECT job_no, unit_rate_aud, qs_unit_rate_aud, date_priced FROM lines WHERE element='rc-l-wall' AND sub_element_attr='200mm' ORDER BY date_priced DESC LIMIT 5;` **Capture timing:** - During Tuesday call: type per-line QS expectations into a scratch table (cowork-lfcs assists). - Within 24 h post-call: run `lfcs-bid-vs-qs-compare` skill which generates the structured `QS-Comparison-{date}.md` and pushes deltas into `pricing-history/`. - Post-award: re-run with awarded rates (if different from QS-shared estimate) — second flywheel pass. **Open question (Rocky decision):** is QS-shared pricing legally OK to capture verbatim, or is there a confidentiality angle with Dec Projects / future head contractors? If sensitive, store anonymised (`qs_id: dec-projects-hash` rather than name) — but slightly less useful. --- ## 7. Implementation phases ### Phase 0 — tomorrow at the office (Mon 2026-05-04) Goal: make the 2602 Munmorah bid (Wed 2026-05-07) better with whatever's already feasible. **Vision-pass on drawings is MANDATORY, not opt-in** (per HQ gap analysis 2026-05-03 Section 6 — Wednesday submission cannot ride on text-extract alone). 1. **Drop source files** into vault folders per `00-brief.md` open items (2 PDFs + 1 xlsx). 2. **Vision-pass every drawing — mandatory.** Pick ONE path: - **Path A (eyes-on, lower setup):** Rocky reads each drawing himself, annotates `Drawing-Index.md` with anything text extraction missed (dimensions outside text labels, section/detail bubbles, hatching, drawn clashes with the BOQ). - **Path B (`pdftoppm` + Cowork drag-drop, ~30 min):** Run `pdftoppm -r 200 ST251342_Munmorah... out` to generate page PNGs. Drag PNGs into Cowork (or local Claude Code). One prompt per drawing: *"This is bridge drawing S01.10. Extract every dimension, material callout, section marker, detail bubble, and any drawn element. Output JSON matching the existing Drawing-Index.md schema."* Paste the JSON into `Drawing-Index.md` as a `vision_findings:` block per drawing. No new code, no new skill, one-shot for THIS bid. - Paths A and B both acceptable; Rocky picks one. Skipping is not acceptable per HQ. 3. **After Tuesday QS call:** cowork-lfcs (or HQ if cowork-lfcs project doesn't exist yet) propagates answers from `Pre-Call-Questions-2026-05-05.md` into `Inclusions-Exclusions.md` and the pricing working sheet. ### Phase 1 — this week (Mon–Fri 2026-05-04 to 2026-05-08) Goal: stand up cowork-lfcs Cowork project + the four MVP-essential bid-prep skills so the next bid runs through them, not through HQ. Build (in order, with effort estimate): 1. **Create cowork-lfcs Cowork project.** ~30 min. Mirror the `cowork-hq` setup but scoped to `11_OpsMan_LFCS/`. Project instructions point to `_Brain/CLAUDE.md`. Read access to `Operations/skills/`. (Rocky decision: Anthropic plan tier — already on Pro / needs upgrade?) 2. **Author `lfcs-job-scaffold`.** ~1 hr. SKILL.md per the chat-bootstrap pattern. Generates the 11-section folder + `00-brief.md` + `README.md` from `job_no` + `client` + `site` + `bid_due` inputs. 3. **Author `lfcs-drawing-extract-text`.** ~1 hr. Codifies what HQ did tonight. Reads PDFs (Cowork's Read tool handles PDFs natively), outputs `Drawing-Index.md` per the existing 2602 template. 4. **Author `lfcs-boq-parse`.** ~1 hr. Reads xlsx (openpyxl in Python or Cowork's xlsx Read), normalises to canonical schema, outputs `boq-normalised.json` + quantities-at-a-glance markdown table. 5. **Author `lfcs-bid-prep-doc`, `lfcs-precall-questions`, `lfcs-incl-excl-draft`.** ~2 hr total. These are template-driven — the 2602 outputs become the templates. Each skill produces its file from the extracts above. 6. **Run the next bid** through cowork-lfcs end-to-end. Don't optimise until you've used it once. Total Phase-1 effort: ~5–6 hr of focused work, splittable across two evenings. **No paid-tool spend** beyond existing Anthropic subscription. ### Phase 2 — this month (May 2026) Goal: vision pipeline scripted, pricing-history live, BOQ↔drawing cross-check automated. 7. **Author `lfcs-drawing-extract-vision`.** ~3 hr. Python script + SKILL.md. `pdftoppm` → PNG → Anthropic API. Dispatched via Claude Code CLI (cowork-lfcs hands the folder, CC CLI does the heavy work). **Requires `ANTHROPIC_API_KEY`** (also needed for the COO architecture, so co-purchase / co-deploy). 8. **Author `lfcs-boq-cross-check`.** ~2 hr. Cross-references `boq-normalised.json` against `Drawing-Index.md` tag soup. Outputs `cross-check.md` with two sections: BOQ-items-without-drawing-ref + drawn-elements-without-BOQ-line. The Drawing-Index already has a manual version of this for 2602 — codify it. 9. **Stand up `pricing-history/` folder + author `lfcs-pricing-history-lookup`.** ~2 hr. Folder under `lfcs-standards/`. One markdown per priced BOQ line. Lookup skill = ripgrep wrapper or 30-line Python. 10. **Backfill pricing-history from past LFCS jobs** if Rocky has 2–5 priced BOQs to import. ~2 hr per job manually; can be skipped if not available. Critical for the flywheel to have signal on day one. 11. **Author `lfcs-bid-vs-qs-compare`.** ~2 hr. Runs after the QS shares pricing. Generates `QS-Comparison-{date}.md` + pushes deltas into `pricing-history/`. Total Phase-2 effort: ~10–12 hr. Spread across 2 weeks at Rocky's bid cadence. ### Phase 3 — scale to 10 jobs (Jun–Aug 2026) 12. **Build the ongoing-project skills** as needed — each one builds when a real job needs it (don't pre-build): - First post-award job triggers `lfcs-rfi-drafter`, `lfcs-variation-drafter`, `lfcs-progress-claim` builds. - First defects-period closeout triggers `lfcs-defects-register`. 13. **Author `lfcs-pricing-estimator`.** Once pricing-history has 5+ jobs of signal (~Phase-3), estimator can apply rate-card + history weighting to a fresh BOQ. Until then, manual rates with history lookup = MVP-good-enough. 14. **At ~5 jobs:** evaluate Stage-C Airtable decision per `PM-Workflow-Pattern.md`. Decision point: are PMs grepping pricing-history? Is it sharpening bids? If yes → migrate to SQLite (cheaper than Airtable). If no → keep markdown. 15. **At ~10 jobs:** consider `lfcs-bid-postmortem` skill for systematic learning capture. --- ## 8. Open decisions for Rocky Ranked: (a) blocks Phase 1, (b) blocks Phase 2, (c) nice-to-resolve later. ### (a) Blocks Phase 1 (this week) 1. **Anthropic plan tier for cowork-lfcs.** Need a Cowork project for the second PM in the office? Pro is single-seat. Team plan ($25/seat/month). Decision: stay solo on Rocky's seat (other PM uses Rocky's instance via screen-share initially) OR upgrade now. Cost: $25/mo extra if upgrading. 2. **Where do skills live, canonically?** Recommend `HQ-Vault/11_OpsMan_LFCS/Operations/skills/lfcs-{name}/SKILL.md` (matches existing chat-bootstrap pattern). Cowork-lfcs reads vault directly; Hermes rsyncs into `~/.hermes/skills/` on cron. Mirror the COO-architecture proposal (point 7 in Open Decisions of that doc). 3. **Add `02d - QS-Comparison/` to canonical folder-spec?** This adds a new sub-folder under `02 - Scope and Pricing/`. Folder-spec.md change requires Rocky's approval per the AI Team Protocol "no new top-level folders" rule (sub-folders are softer but still nudge to confirm). ### (b) Blocks Phase 2 (this month) 4. **`ANTHROPIC_API_KEY` acquisition.** Same key needed for COO architecture. Suggest acquire once, share across surfaces. Cost-cap recommended: $30/day soft cap initially (covers ~750 vision-API calls = ~100 drawings/day). Adjust after observing. 5. **Vision-pass cost-per-bid budget OK?** Estimated $0.30/job at 7 pages × 50 jobs = $15/year. Trivial — no decision needed unless cap-paranoid. 6. **Confidentiality on QS-shared pricing.** Capture verbatim or anonymise? If Dec Projects ever asks "are you using my pricing data to win other bids?", answer matters. Default to anonymised job/QS identifiers in `pricing-history/` until Rocky says otherwise. 7. **Second-PM access model.** If the other PM in the office runs his own ~5 bids through this system, does cowork-lfcs sit on his desktop, on Rocky's, or shared? Affects Anthropic plan + commit-author identity + log attribution. ### (c) Nice-to-resolve later 8. **Pricing-history backfill — worth the time?** ~2 hr per past job. Worth it if Rocky has 3–5 priced BOQs handy that capture different element types. Punt if not. 9. **Drawing extraction model — Sonnet 4.6 or Opus 4.7?** Sonnet at $0.04/page is the recommendation. Opus would be ~5× cost for marginal recall gain. Test on 2602 once and lock. 10. **Scaling decision point — keep at Stage-C trigger (5 jobs)?** Or revisit earlier if office takes off? 11. **Airtable: ever?** Recommend not, until proven need from second PM or Robert. 12. **Hermes upgrade to v0.12.0?** Per COO architecture doc — might unlock cleaner cron + plugin patterns. Not blocking the bid system. --- ## 9. Lane handoffs — what happens where | Surface | Owns | Doesn't own | |---|---|---| | **Rocky** | Strategic decisions, signing, calls (Tuesday QS), eyes-on drawings (vision-pass), final pricing call, irreversible commits (submission) | Nothing the system can do for him | | **cowork-lfcs (desktop)** | Bid prep stack end-to-end (scaffold → extract-text → boq-parse → bid-prep-doc → precall-q → incl-excl), drawing review chat, drag-drop file intake, dispatch to CC CLI for heavy work, post-call propagation, log writes per protocol | Code work (none in scope), on-site capture (Hermes), 24/7 cron (Hermes) | | **Hermes (VPS)** | On-site dictation, photo filing, EOD summary, RFI status queries, docket tracking, defects register entries from Telegram, weekly programme push, dispatched ops requests via COO inbox | Bid prep heavy lifting (dispatches to CC CLI), strategic decisions (Rocky), code merges (locked per safety rails) | | **Claude Code CLI (dispatched)** | Heavy Python (vision API loop, BOQ parse, pricing-history sync, BOQ↔drawing cross-check), bounded `--allowedTools` per dispatch, JSON-out for parent surface to consume | Standing daemon work (Hermes is the daemon), Rocky-facing chat (cowork-lfcs is the desktop driver) | | **cowork-hq** | Strategic / cross-project oversight, the gap analysis on this plan, escalations from the COO architecture | Day-to-day bid prep (cowork-lfcs's job once it exists), on-site (Hermes) | **Key handoff sequences:** - **Bid intake:** Rocky drops files → cowork-lfcs invokes `lfcs-job-scaffold` → cowork-lfcs invokes `lfcs-drawing-extract-text` (in-Cowork) → cowork-lfcs dispatches `lfcs-drawing-extract-vision` to CC CLI (heavy) → cowork-lfcs invokes `lfcs-boq-parse` + `lfcs-boq-cross-check` → cowork-lfcs invokes `lfcs-bid-prep-doc` + `lfcs-precall-questions` + `lfcs-incl-excl-draft` → Rocky reads, Tuesday call, post-call propagation in cowork-lfcs. - **Post-call pricing:** Rocky drives, cowork-lfcs assists, `lfcs-pricing-history-lookup` queries past jobs, manual rate fill (or `lfcs-pricing-estimator` once Phase 3). - **QS feedback:** Tuesday call → Rocky types deltas in scratch → cowork-lfcs runs `lfcs-bid-vs-qs-compare` → flywheel ingest. - **On-site (post-award):** Rocky Telegram → Hermes → vault writes to `_AgentLog/` + dockets/photos/diary. - **Async ops requests** (e.g. "audit drawing-index for missing tags across all 2026 jobs"): Rocky writes to `_System/COO-Inbox.md` → Hermes-COO classifies → dispatches to CC CLI → result back in inbox. --- ## 10. Risks + mitigation | Risk | Likelihood | Impact | Mitigation | |---|---|---|---| | Vision-pass misses critical drawn detail | Medium | High | Rocky still does eyes-on every drawing per `PM-Workflow-Pattern.md` Step 9. Vision is augmentation, not substitute. Skill output is `vision_findings:` block — clearly tagged, never overwrites text-extract block, always reviewable. | | Pricing-estimator over-fits early jobs and produces bad rates on novel scope | Medium | Medium | MVP doesn't include estimator — manual rates with history lookup. Estimator only lands at Phase 3 once 5+ jobs of signal exist. Until then, history-lookup informs Rocky, doesn't decide. | | Skill catalog drift between vault canonical + Hermes `~/.hermes/skills/` rsync copy | Low | Medium | One-way sync (vault → Hermes), idempotent, runs on cron. Canonical = vault. Per the COO-architecture Open Decision (point 7) — same approach. | | 2602 Munmorah bid suffers because the system isn't ready in time | Medium | High | Phase 0 plan is explicit: no new tooling required for THIS bid. Rocky vision-passes manually + can opt in to one-shot Cowork drag-drop for vision findings. The system being immature doesn't break the existing one-shot HQ scaffold approach. | | Other PM in the office doesn't adopt the system | Medium | Medium | Don't roll out to him until Rocky has run 2–3 bids through it himself. Adoption from a working system is easier than adoption from a half-built one. | | QS-shared pricing capture creates legal/relationship risk | Low | Medium | Default anonymised `qs_id` until Rocky confirms otherwise. Confidentiality clause check before first capture. | | Hermes-as-COO doesn't ship → manual dispatch overhead falls back on cowork-lfcs | Medium | Low | Bid system stands alone — doesn't require COO to function. cowork-lfcs can dispatch CC CLI directly via Bash from Cowork's desktop session. COO is the autonomous-overnight bonus, not the prerequisite. | | Anthropic API spend grows quickly with vision-pass + dispatched skills | Low | Low | $0.30/bid × 50 bids/year = $15/year for vision. Pricing-estimator + cross-check + bid-prep-doc add maybe $0.50/bid each. Total ~$2/bid × 50 = $100/year. Negligible vs. cost of one missed exclusion. Cap-and-alert anyway per Open Decision 4. | | Folder-spec mutation (adding `02d - QS-Comparison/`) propagates inconsistently across past jobs | Low | Low | Append-only — past jobs without `02d/` are fine; no migration needed. New jobs get the sub-folder via `lfcs-job-scaffold`. | | Skills rot (templates change, file paths shift, models deprecated) | Medium | Medium | Skills are version-controlled in vault. `_Log.md` in `Operations/skills/` (new file, append-only) tracks each skill version + date + reason. Test each skill on a known good fixture before deploying. | --- ## What COO (this Claude Code instance) cannot do alone - **Drag-and-drop file intake.** Headless CC CLI doesn't have a desktop GUI. Cowork-lfcs is the right surface for "drop drawings here." - **Synchronous pricing conversation with Rocky.** Cowork-lfcs handles the chat loop; CC CLI is for dispatched batch work. - **Telegram on-site dictation.** Hermes is the Telegram-bound surface; CC CLI doesn't sit on a Telegram bot. - **24/7 cron-driven autonomy.** Per the COO architecture, Hermes is the daemon. CC CLI runs per-dispatch then exits. - **Strategic / commercial calls.** Anthropic plan tier, paid-tool spend, pricing confidentiality, second-PM rollout — all Rocky's calls. The right shape is COO authoring + maintaining the skill catalog (versioned in vault), Cowork driving the synchronous bid-prep workflow, Hermes-as-COO dispatching async COO-inbox requests to CC CLI for the heavy work. Three surfaces, one catalog, one vault, one source of truth. --- ## Plan checklist before HQ gap analysis - [x] Read everything in user's specified order - [x] System architecture (ASCII + paragraph) - [x] Skill inventory (table with name | purpose | I/O | deps | MVP/v2 | surface) - [x] Drawing extraction recommendation (concrete tooling + cost/speed/quality) - [x] Pricing data model (markdown MVP → SQLite v2; Airtable deferred) - [x] QS-feedback flywheel schema (capture file + per-line schema + lookup query) - [x] Implementation phases (Phase 0 = tomorrow; Phase 1 = this week; Phase 2 = this month; Phase 3 = ~10 jobs) - [x] Open decisions for Rocky (ranked by what blocks what) - [x] Lane handoffs (Rocky / cowork-lfcs / Hermes / CC CLI / cowork-hq) - [x] Risks + mitigation - [x] Honest "open question" labels where I don't know vs filled answers - [x] No code written, no live config touched, no paid tool committed without flagging Awaiting `## Gap Analysis — cowork-hq — {date}` section appended below by HQ on next session. --- ## Gap Analysis — cowork-hq — 2026-05-03 > HQ pass on COO's plan per the protocol set in the original COO prompt. Honest critique. Strengths noted briefly; gaps + risks called out by the eight criteria HQ committed to. ### Strengths (one paragraph, no padding) Architecture is cleanly separated (skills as canonical units, three execution surfaces, vault as source of truth). Drawing-extraction recommendation (Sonnet vision via CC CLI dispatch) is the right tradeoff. Markdown→SQLite→maybe-Airtable progression is correct cost-aware sequencing. Phase 0 explicitly does NOT block on the new system — Wednesday bid can ship with current scaffold + manual vision-pass. Lane handoff table is precise. Risks section is honest. **Plan is ship-ready as a v1 design** — gaps below are refinement, not redesign. ### 1. Coverage — what's missing from the use-case set Plan covers bid prep, ongoing project, cross-project, QS feedback. **Missing skills/workflows:** - **`lfcs-site-recon`** — pre-bid site visit. Photos, conditions checklist, access notes. Critical for Munmorah (saltwater, power station access) and any rural/industrial site. Currently no flow for "I went to site, captured these things." - **`lfcs-subby-quote-intake`** — when LFCS sends scope to subbies and they quote back, where does that capture happen? Sub-rates feed LFCS unit rates. Without this skill, pricing-history lacks supply-side cost data. - **`lfcs-tender-correspondence`** — email thread management with QS during bid week. Currently `06a - Emails/` is just a folder; no skill drives the inbox→file→reference loop. - **`lfcs-tender-tracker`** — bid status (submitted / awaiting / won / lost / withdrawn) at portfolio level. Cross-job dashboard. Needed once you have 5+ live bids. - **`lfcs-contract-review`** — post-award diff between awarded contract and submitted bid. Catches scope drift in the contract before Rocky signs. Cheap to skip once, expensive when it bites. - **`lfcs-boq-generator`** — for tenders where the client provides scope only and contractor builds the BOQ. Plan assumes BOQ always arrives — many don't. Recommend: add to skill inventory at v2 priority, build as real bids demand them. ### 2. Lane discipline — three lanes need sharpening - **`lfcs-defects-register` / `lfcs-progress-claim`** listed as "Hermes + cowork-lfcs." Ambiguous ownership = nobody owns it. Recommend: **input** capture = Hermes (Telegram dictation, photo intake); **artefact authoring** = cowork-lfcs (the formal markdown / xlsx). One owner per artefact. - **`lfcs-pricing-history-lookup`** listed as "cowork-lfcs / Hermes." Hermes runs MiniMax — quality ceiling for pricing judgment. Recommend: **simple lookups** ("show me last 3 jobs that touched X") = Hermes is fine; **judgment** ("should I price this at $380 or $410") = cowork-lfcs primary. - **Hermes-as-COO dispatch dependency.** Plan correctly notes the bid system stands alone if COO doesn't ship. Good. **But verify before Phase 2:** can cowork-lfcs Bash directly invoke local Claude Code CLI without the Hermes daemon layer? If yes (likely), Phase 2 is unblocked even if COO architecture slips. Recommend smoke-test this on Phase 1 first day. ### 3. Cost sanity — solid but two flags - $400/year max ongoing is fine. ✅ - 17 hr of build effort spread over a month ✅ realistic. - **Hidden cost:** maintenance. Skills rot — model deprecations, template drift, schema migrations. Budget 2–4 hr/month for catalog upkeep. Currently invisible in the plan. Add to Risks. - **Hidden cost:** the second PM's onboarding. Plan flags Anthropic Team-plan decision but not the *onboarding* cost. Half a day at minimum to get him productive. Should be in Phase 3. ### 4. Drift from existential priority — HARD FLAG This system is **100% LFCS work**. Zero hours benefit RateRight worker supply hunt — your `[[Active]]`-pinned existential priority. Today's session burned ~12 hours across HQ + COO on LFCS-related design and scaffold (legitimate fire for the bid). Phase 1 is another 5–6 hr this week. Phase 2 is 10–12 hr this month. Phase 3 is 5+ hr/month ongoing. - **Phase 1 is justifiable** — bid wins = LFCS revenue = paycheck = enables RateRight runway. - **Phase 2 is conditional** — should not start until either (a) RateRight worker-supply hunt has materially advanced (3+ supply-side outreach actions logged), OR (b) bid system has demonstrably won 2+ bids that wouldn't have otherwise. - **Phase 3 is gated on Phase 2 demonstrating value AND existential priority being on track.** Add this as **Open Decision (a) #4** (Phase-2 trigger gate). HQ will surface this in Friday's weekly review. ### 5. Scaling realism — pricing schema gap at 50+ jobs Markdown→SQLite progression is fine for storage. **But the schema itself isn't comparison-ready at scale.** - **No controlled vocabulary for `element` / `sub_element`.** At 50 jobs you'll have 200+ unique element strings (`abutment`, `bridge-abutment`, `RC-abutment`, `bridge_abutment`, `Abutment`...). Aggregate queries return inconsistent rows. - **No `complexity_factor` or `multiplier_factors` field.** COO's own QS-comparison example flagged this ("LFCS over-priced for height/access") — but the schema doesn't capture it. Without it, history lookups for "200mm RC L-wall" don't separate easy-access from hard-access jobs and average rates are misleading. - **Recommendation:** define `lfcs-standards/element-taxonomy.md` BEFORE first pricing-history line lands. Starter taxonomy: 20–30 elements (abutment, wingwall, deck, approach-slab, headstock, parapet-barrier, footing, RC-l-wall, etc.) with explicit `aliases:` lists. Add `complexity_factors:` to per-line schema (e.g. `[height-over-3m, salt-water-proximity, restricted-access, night-shift]`). Cleanup-debt avoided. - Effort: 1 hr to draft, refined over time. ### 6. Drawing-extraction tooling — Phase 0 needs restructuring Plan presents pdftoppm + Cowork drag-drop as "opt-in for tomorrow." For a Wednesday bid this should be the **mandatory** Phase 0 step, not an option. Restructure Phase 0 to: 1. Drop source files into vault (existing). 2. Vision-pass on every drawing — either (a) eyes-on with annotations to `Drawing-Index.md`, OR (b) pdftoppm + Cowork drag-drop with structured extraction. Pick one, do it. **Not optional.** 3. Propagate Tuesday answers post-call. Reason: text extraction missed drawn detail. The 2602 `Drawing-Index.md` HQ wrote tonight has a `confidence flags` caveat saying so. Wednesday submission can't ride on text-only extraction. ### 7. Hidden assumptions — six - ✅ Plan flags: BOQ always arrives (some tenders don't). Recommend `lfcs-boq-generator` — added above. - ✅ Plan flags: Hermes-COO might not ship (bid system stands alone). Good. - ❌ Unflagged: **Cowork → CC CLI Bash dispatch** is asserted but untested. Smoke-test on Phase 1 day one. - ❌ Unflagged: drawings always come as PDFs. **DWG (CAD) files are common** in industrial work. Pipeline has no path. Add as v2 risk + Phase-3 skill (`lfcs-dwg-extract` via libdwg or DWG→PDF conversion step). - ❌ Unflagged: **scanned/raster PDFs** (some old or low-budget tenders) — text-extract returns nothing, vision-pass is the only path. Pipeline handles this incidentally but doesn't flag the cost difference (vision-only = full cost per page, no text-extract savings). - ❌ Unflagged: **second-PM adoption friction.** Plan covers technical access but not the human "why would I use this" angle. Recommend: don't roll out to him until 2–3 of Rocky's bids have demonstrably benefited (per Phase-2 gate above). - ❌ Unflagged: **QS pricing not always shared.** Plan's flywheel assumes QS reveals their numbers. Many won't. Schema should support `qs_unit_rate_aud: null` with `qs_share_status: declined-to-share | not-asked | shared-verbal | shared-written`. Lookups should distinguish. ### 8. Open decisions — re-ranked COO's ranking is reasonable. HQ's tightening: **(a) Blocks Phase 1:** 1. **Anthropic plan tier** — only blocks if second PM joins Phase 1. Recommend: stay solo on Rocky's seat for Phase 1, defer Team-plan decision to Phase 3 (when second PM actually onboards). Saves $25/mo for 6+ weeks. 2. **Skills location** — easy yes to `Operations/skills/lfcs-{name}/SKILL.md`. Mirrors COO architecture decision. No real decision needed; just document it. 3. **`02d - QS-Comparison/` folder addition** — easy yes. Append-only sub-folder, no migration risk. Approve. 4. **(NEW from HQ) Phase-2 trigger gate** — Phase 2 doesn't start until existential-priority condition met OR Phase 1 wins ≥2 bids. Recommend: yes. **(b) Blocks Phase 2:** 5. **`ANTHROPIC_API_KEY`** — same key as COO architecture. Acquire once, shared. 6. Cost cap — $30/day soft cap as COO suggests. Fine. 7. **QS-shared pricing confidentiality** — default anonymised. Reconfirm with Robert (Dec Projects) in Tuesday call: "OK if I capture your benchmarked rates for our internal estimating, anonymised?" If yes, capture by name. If hesitant, anonymise. 8. **Second-PM access** — defer to Phase 3. **(c) Nice-to-resolve later:** 9–12 fine as listed. ### Additional gaps not in COO's open decisions - **Element taxonomy** — define before first pricing-history line. (Section 5 above.) - **Test fixture** — formalise 2602 Munmorah as the canonical regression fixture. Every new skill must reproduce or improve 2602 outputs. Add to `Operations/skills/_README.md` as deployment gate. - **Skill catalog log** — append-only `Operations/skills/_Log.md` tracking version + date + reason for each skill. COO mentioned in Risks but didn't operationalise. - **Cavekit / cavemem assessment** — original COO prompt asked for this. Plan doesn't include it. Either COO judged not relevant (which should be stated), or they were missed. Recommend: COO returns a 1-paragraph each on whether cavekit could shortcut Phase 1 skill scaffolding and whether cavemem could replace SQLite at Phase 3. **Don't adopt either yet** — but the assessment was scoped and is owed. - **DWG/raster PDF handling** — flag as v3 backlog (Section 7 above). ### HQ verdict **Plan is approved for Phase 0 + Phase 1 with the refinements above.** Phase 2 is approved *contingent on the trigger gate* (existential priority advance OR Phase-1 wins). Phase 3 is approved as scoped — re-evaluate at trigger. **Immediate next actions:** - Rocky: review the four blocking decisions above (plan-tier, skills-location, `02d` folder, Phase-2 gate). Decide tomorrow at office before kicking off Phase 1. - COO (claude-code-coo): in next session, append a 2-paragraph cavekit/cavemem assessment to this plan doc, plus add `lfcs-site-recon`, `lfcs-subby-quote-intake`, `lfcs-tender-correspondence`, `lfcs-tender-tracker`, `lfcs-contract-review`, `lfcs-boq-generator` to the skill inventory (v2 priority). Keep using Caveman Lite — output quality holds up well. - HQ: flag the Phase-2 trigger gate in Friday's weekly review. --- ## COO Response — claude-code-coo — 2026-05-03 > Returning the items HQ queued: cavekit / cavemem assessment + maintenance budget addendum. Refinements (Phase 0 mandatory vision-pass, schema additions, lane sharpening, 6 missing skills) edited inline above. ### Cavekit assessment — 1 paragraph Cavekit (Anthropic's skill-scaffolding tool, distributed via the `caveman` plugin family) generates SKILL.md + Python scaffolding from a one-line description. **Could shortcut Phase 1 skill authoring? Yes, marginally — not worth adopting yet.** The five Phase-1 SKILL.md files (job-scaffold, drawing-extract-text, boq-parse, bid-prep-doc, precall-questions, incl-excl-draft) follow the chat-bootstrap pattern that is already canonical in `Operations/skills/chat-bootstrap/SKILL.md`. Manual authoring against that template gives higher fit-to-the-LFCS-conventions (rate-card refs, folder-spec compliance, append-only protocol awareness) than a generic generator would. Cavekit is better for the Phase-2 Python-heavy skills (drawing-extract-vision, boq-parse-with-openpyxl, bid-vs-qs-compare) where the Python boilerplate is real work. **Recommendation:** revisit cavekit at Phase 2 entry. For Phase 1, hand-author from chat-bootstrap pattern (already in progress this session). ### Cavemem assessment — 1 paragraph Cavemem (caveman-compressed memory format) cuts token cost ~60% on memory files at the cost of human readability. **Could replace SQLite at Phase 3 for pricing-history? No.** Cavemem optimises the wrong axis for this use case: pricing-history needs deterministic structured queries ("AVG unit_rate_aud WHERE element=X AND complexity_factors INCLUDES Y"), not LLM-friendly compressed prose. SQLite is the right fit for ~10k-row aggregate analytics. Cavemem IS plausibly useful for compressing the per-job _Brain/_Log.md files and `00-Bid-Prep.md` files once a job is closed-out (saves Cowork context spend on cross-project lookups), but that's a separate optimisation tracked under HQ memory hygiene, not the bid system. **Recommendation:** do not use cavemem for pricing-history. Consider for `_Archive/` compression at Phase 3+ only if Cowork/Hermes context-spend becomes a real cost driver (not currently the case). ### Maintenance budget addendum (per HQ Section 3) Add to Section 8 Open Decisions (c) Nice-to-resolve later: 13. **Skill catalog maintenance budget — 2-4 hr/month.** Skills rot via model deprecations, template drift, schema migrations, vault structure changes. Budget the time explicitly. Recommend: 30-min monthly catalog audit on the first weekend of each month (cross-reference SKILL.md files vs current vault structure + chat-bootstrap pattern + folder-spec). Bigger refactors (model upgrades, schema migrations) batched quarterly. Add to Section 10 Risks: | Risk | Likelihood | Impact | Mitigation | |---|---|---|---| | Skill catalog drift from monthly maintenance neglect | Medium | Medium | Calendarised 30-min audit first weekend monthly. `Operations/skills/_Log.md` append-only tracks last-touched-date per skill; flag any skill silent for 90+ days for review. | ### Phase-1 build delivered this session (2026-05-03 evening, post-HQ-gap-analysis) - Plan doc refinements above - `Operations/skills/_README.md` + `_Log.md` (catalog scaffolding) - 6 SKILL.md files: `lfcs-job-scaffold`, `lfcs-drawing-extract-text`, `lfcs-boq-parse`, `lfcs-bid-prep-doc`, `lfcs-precall-questions`, `lfcs-incl-excl-draft` - `lfcs-standards/folder-spec.md` updated with `02d - QS-Comparison/` - `lfcs-standards/element-taxonomy.md` (Phase-2 precondition, drafted ahead) - `lfcs-standards/pricing-history/README.md` (folder + schema doc; no data yet — Phase 2 gated) NOT delivered (gated / requires Rocky): - cowork-lfcs Cowork project setup (Rocky's desktop, Anthropic plan decision) - ANTHROPIC_API_KEY acquisition (Rocky) - Phase 2 skills (gated on supply-hunt advance OR ≥2 bid wins) - Vision-pass on 2602 drawings (Rocky's eyes-on tomorrow) End of COO response.