2026-07-23

Research note: the repair-shop operational model (field-proven blueprint)

Not build-committed. This is the ACTUAL system the shop ran for years — the reference model the AI-orchestrated platform generalizes. Captured because it is the domain expertise.

The workflow (ticket-driven, osTicket)

Everything ran through one ticket. Canned per-department responses gated each transition: 1. Intake. Drop-off on the counter (later: locker drop). Remote CSR (Katrina, in the Philippines) via camera + remote-desktop to the CS machine: customer opens their account, CSR photographs everything together — contract + ID — and uploads to the ticket so the customer gets a copy too. (Transparency = trust; kept "weirdos" out.) 2. Estimate + consent. Ticket sends the estimate with a link; customer replies "yes I agree, repair my computer." Only THEN charge the card. 3. Parts. Order the part → "part ordered" status → when it arrives, "waiting for part" → check it in → notify "soon to be attended to." 4. Repair (Windows, the common path). Boot off USB → copy files off → erase → reinstall Windows (initial setup done FIRST) → blindly drag one folder named the ticket number back → boot to the login screen. Never see a filename. 5. Proof. Photograph the working login screen → post to the ticket (customer sees it's fixed). Wrap the machine in plastic so everything stays together. 6. Notifications. Running behind / started / done + the bill. 7. Pickup. Pay the bill → receive the locker combination to retrieve it. Payment-gated, no loitering in the shop.

Why it worked (the principles, all field-proven)

employees ("mostly hardware") and a remote CSR could execute reliably. THIS is the platform: software+process hold the judgment; the hands can be less-skilled or remote/vetted.

worker protection (zero exposure to disturbing/illegal content).

trail, shared with the customer.

have to remember." AND the skill to investigate (employee-usage-policy monitoring) used ONLY per policy/authorization. The power to look; the discipline not to. That's the whole consent/guardrail stance of this engagement, lived.

Maps 1:1 onto what we designed today

| Shop practice | Today's design | |---|---| | "Yes I agree, repair my computer" link | consent gate (fail-closed) | | Ticket trail + completion/ID photos | WORM audit-log + screenshot provenance | | Ticket-number blind folder drag | blind data-handling (handle-without-inspecting) | | osTicket status flow (estimate→approved→part→…→paid→pickup) | intent-first + status transitions + reconcile | | High-schoolers/remote CSR run the procedure | vetted-technician dispatch; expertise in the software | | Locker combo on payment | payment-gated completion / escrow | | Photograph the fixed login screen | two-oracle verify (visual proof of the done state) |

Implication

The hardware-inventory library crate (Sprint 2.9) is ONE component. The larger platform is this operational model, generalized: AI + software hold the expertise (remote, sight-independent), vetted local technicians are the hands, companies/customers move through the same consent-gated, privacy-preserving, provenance-logged ticket flow the shop already proved works.

Stack + build discipline ("everything thing," done right)

Three pieces + an owned library. The breadth is in the CAPABILITIES, not the tech — that's good architecture, not sprawl (sprawl = many languages/services; this = one coherent foundation).

Hardware-analysis (Sprint 2.9) = capability #1. The gates enforce this; it's what stops an "everything platform" from becoming vaporware. Never a boil-the-ocean rewrite.

rent — fits the no-Twilio-rent stance), capable. "Something better" candidate = SignalWire (FreeSWITCH creator's programmable cloud, same DNA) IF cloud/programmable voice is ever wanted. Solved, swappable component — don't over-optimize.

Technical infrastructure (platform components + a security capability)

The shop's technical spine, to reimplement/orchestrate on Forge (compose, don't rebuild):

test/wipe/recovery without a USB) — the bootusb lineage.

WipeMethod already in operations-drive-health).

every untrusted machine put on the network gets its OWN isolated segment (VLAN / netns / isolated bridge + own DHCP) so it can't touch other machines/customer data/shop infra (blast radius zero). A passive listener on that segment (Zeek/Suricata/structured tcpdump) watches behavior and flags "acting wrong": C2 beaconing, exfil, port-scanning, DGA/bad-DNS. In a repair shop the machines are often INFECTED (that's why they're in) — the traffic IS the diagnosis. Extends operations-net-discovery + infrastructure-security-scan.

watch BEHAVIOR (is it phoning home to malware?), never read the customer's CONTENT. Detect the C2 callout; don't snoop the drive. Same blind-handling line. Disclosed.

and if yours is infected we'll know AND have the evidence."

Remote management / delivery layer (RMM — field-proven, bash)

tunnel to a hardened phone-home server (pf-locked-down; only the operator gets in). Outbound-only = works behind ANY NAT/firewall with ZERO inbound holes on the customer side: the endpoint reaches out, you reach back through the tunnel. Whole attack surface collapses to one hardened box.

desktop (X / RustDesk).

one-off repairs.

this exact reverse-tunnel; remote diagnostics + actuation run over it. The shop-in-a-box ships through this, billed monthly.

Cloudflare Tunnel / ngrok (the reverse tunnel productized); TacticalRMM / Atera / NinjaOne / ConnectWise (phone-home + terminal + MSP subscription productized). The bash RMM was early + right.

terminal-centric; AI-in-a-terminal (this session's shape) reads output + runs commands, so managed services can run again remotely without squinting at small detail.

infra, WORM-logged. The phone-home server is keys-to-the-kingdom — its hardening + audit is the core responsibility.

USD — Universal Service Daemon (the core agent / client spine)

One minimal daemon on every managed machine — OUTBOUND-ONLY, NO open ports, phones home to a hardened control plane, orchestrated by "the robot" (automation/AI, not manual login) — that delivers UNIVERSAL SERVICE: health monitoring, diagnostics, remote support, actuation, and stolen-device phone-home all ride the same secure channel. One daemon, universal service, zero LAN attack surface.

a listener that gets exploited (Kaseya-style supply-chain vector). Outbound-only + no listeners = the endpoint is invisible/unreachable on the LAN. Better than the billion-dollar products.

the AI now occupies (manage the fleet over the tunnels, tireless, scripted).

anything through the tunnel). So harden the control plane, gate on consent (subscription), WORM-log every action. Single responsibility = the elegance.

the health library crates, foundation-audit-log (WORM), + the reverse-tunnel transport. Every platform capability is a USD-delivered service, not a separate agent.

#### USD modern stack (the Forge/Rust rebuild of the bash RMM)

web traffic, tunnels through any proxy/NAT/captive firewall raw SSH can't — SAME zero-inbound surface (client opens out, listens on nothing). Still carries SSH / a terminal INSIDE it, so "all I need is a terminal" is preserved. NOTE: this is exactly the bridge used all session (Claude → server → WS → extension → browser); the USD pattern is already the runtime.

couldn't be. (The Forge framework.)

executes in a sandbox it can't escape (a buggy/hostile capability can't own the host); runs anywhere incl. a browser control-plane UI. Framework already uses WASM (the mouse humanizer).

the health time-series rendered = the customer-facing value ("your fleet health over time").

delivers — a service on the daemon, billed in the subscription, graphed on the dashboard. Full business assembled: outbound-only secure agent → managed subscription → capabilities (health/diagnostics/support/recovery) → dashboards.

plane verifies the endpoint's cert (only enrolled machines connect; NO shared secret to steal).

+ WORM AssetEnrolled, one act). Revoke cert = the kill switch — stolen/decommissioned machine instantly loses phone-home/management/access.

machine ("endpoint FZFT0Z3 ran this wipe" is proven, not claimed).

rustls in Rust. Ties to ADR-0017 fingerprint + Sprint 1.3 node-lock (per-machine crypto id already in-flight) — wire the cert to the fingerprint that exists.

AI-in-the-loop + promote-to-Rust ratchet (the operations intelligence layer)

The USD collects data → ships it via infrastructure-ai connectors (anthropic/openrouter/ollama + the ask-ai bridge) to the AI. Three tiers with a ratchet between them: 1. Deterministic Rust procedures — the known cases. Fast, TDD'd, cheap, no AI, no hallucination risk. The core. 2. Bounded AI autonomy — the "choices we're allowed to do": AI acts within the consent/budget policy (e.g. auto-order the fan under $X). WORM-logged. 3. AI on the novel long-tail — "things we haven't thought about": analyze, propose/guide, or escalate to the human when beyond bounds.

formal, tested Rust procedure → graduates to Tier 1. The frontier SHRINKS; the system gets more deterministic, more reliable, cheaper over time; the AI always works the shrinking unknown. AI = R&D; Rust = production.

it graduates through the SAME gates (TDD, mutation-proof, 3-AI consensus). AI never silently bakes itself in. An AI fix must EARN determinism.

promote from a real record, not a vibe.

hand-rolled apps → one library crate; this lifts a proven solution from N AI-handled incidents → one Rust procedure. Same discipline, new domain. Nothing permanent is ever "the AI said so."

Self-service + AI-coached field service (the full loop)

Flow: customer push-button self-diagnose (from the server/portal) → USD collects data → infrastructure-ai connectors ship it to the AI for analysis (operator doesn't have to) → auto-order the part (bounded autonomy) → dispatch a local tech → AI coaches the tech through the repair in real time (reads him the facts + diagnostic + prior conversations + proven procedures until he knows what he's doing).

it you need expert techs in every city (rare/expensive/unstaffable). With it you need mechanically-capable hands the AI can guide — orders of magnitude larger labor pool, lower cost. Expertise lives in AI + procedures, DELIVERED on-site in real time. Every capable person in every city becomes a potential technician.

diagnostic data + prior conversations + proven procedures. Facts, cited.

designed it; isn't the bottleneck. Sight-independent, scales past one person.

(two-oracle proof, = the "photograph the fixed login screen" practice); novel/risky → escalate to a human. AI advises; the human tech executes and can refuse. Bounded like all autonomy.

every city at once, for customers/techs they'll never meet.

Telephony / CSR layer (FusionPBX) — humans augmented, not replaced

rebuild (like application-tickets for ticketing).

(the CSR knows who + what's wrong before "hello"); call creates/attaches a ticket; click-to-call from a ticket; voicemail → transcript in the ticket.

summarization back to the ticket; real-time context fed to the human CSR mid-call.

phones, capable local techs on the hands — real jobs, coordinated + AUGMENTED by AI, not eliminated. AI gives the CSR instant context and the tech an expert-in-his-ear; it fires neither. AI multiplies humans and CREATES work; one architect holds the whole thing.

Business model (the real product): vertical SaaS — "shop-in-a-box" for repair

or wiring to build ticketing/ledger/parts/privacy automation. They never had a Dan. That gap is the market. The "vetted technicians" are CUSTOMERS/partners, not just dispatched labor.

both seats lived. A coder without a shop can't replicate it; a bench tech never built the ledger.

Jobber (home services), but for independent COMPUTER repair, which nobody has really done — with privacy-first / blind-handling / consent-gated DNA built in.

founder occupies the sight-independent systems+vision seat. The thing proven today.

+ onboarding. "Here's how a real shop protects the customer AND the tech, proven over years."

proof photo→locker/escrow) + hardware-inventory/health/diagnostics + WORM provenance + the consent/transparency guardrails. All the research notes in this dir are its component specs.

All writing