great-cto 2.73.1 → 2.75.0

package/dist/adapt.js

@@ -160,9 +160,6 @@ using it for pattern-matched work silently skips specialist review.
 | Play Store, App Store, iOS/Android release | \`mobile-store-reviewer\` |
 | API contract: OpenAPI, GraphQL schema, webhook signatures | \`api-platform-reviewer\` |
 | Voice/IVR/telephony, Twilio, recording-consent, TCPA | \`voice-ai-reviewer\` |
-| Clinical / SaMD / FDA / FHIR / PHI | \`ai-clinical-reviewer\`, \`fda-reviewer\` |
-| Wearable telemetry, HealthKit, Health Connect, Garmin, Samsung Health, fitness AI, mental health AI, nutrition AI, supplement AI, physician HITL | \`digital-health-reviewer\` |
-| Lending, ECOA, FCRA, NMLS, adverse action | \`lending-credit-reviewer\` |
 | HR-AI, hiring, AEDT, resume screening | \`hr-ai-reviewer\` |
 | Infra-as-code: Terraform / Helm / CDK / Pulumi | \`infra-reviewer\` |
 | Performance regression, hot path, p99 budgets | \`performance-engineer\` |

package/dist/archetypes.js

@@ -1100,9 +1100,8 @@ export function pickArchetype(d) {
     };
 }
 /** Niche packs that should surface even at high confidence */
-function isNichePack(pack) {
-    return ["robotics-pack", "climate-pack", "drug-discovery-pack",
-        "clinical-trials-pack", "em-fintech-pack"].includes(pack);
+function isNichePack(_pack) {
+    return false;
 }
 /**
  * Infer likely domain packs from README/infra keywords when the archetype
@@ -1112,22 +1111,10 @@ function inferPackHints(d) {
     const hints = [];
     const kws = new Set([...d.readmeKeywords, ...(d.infraKeywords ?? [])]);
     const has = (...terms) => terms.some((t) => kws.has(t));
-    if (has("robot", "ros2", "ros 2", "cobot", "drone", "uav"))
-        hints.push("robotics-pack");
-    if (has("carbon", "ghg", "mrv", "emission", "verra", "sbti"))
-        hints.push("climate-pack");
-    if (has("clinical", "ctms", "edc", "cdisc", "randomization", "irb"))
-        hints.push("clinical-trials-pack");
-    if (has("drug discovery", "binding affinity", "admet", "chembl", "alphafold"))
-        hints.push("drug-discovery-pack");
     if (has("recruit", "hiring", "candidate", "ats", "aedt"))
         hints.push("hr-ai-pack");
-    if (has("loan", "lending", "bnpl", "underwrit", "fcra"))
-        hints.push("lending-pack");
     if (has("voice", "telephony", "ivr", "stt", "tts", "outbound call"))
         hints.push("voice-pack");
-    if (has("india", "upi", "rbi", "mpesa", "gcash", "pix", "cross-border", "remittance"))
-        hints.push("em-fintech-pack");
     if (has("public api", "api key", "developer portal", "openapi"))
         hints.push("api-platform-pack");
     return hints;
@@ -1331,6 +1318,13 @@ export const REVIEWERS_BY_ARCHETYPE = {
     "gov-public": ["gov-reviewer", "security-officer"],
     "insurance": ["insurance-reviewer", "regulated-reviewer"],
     "defense-govcon": ["cmmc-reviewer", "gov-reviewer", "security-officer"],
+    // Product Builder archetypes (A1–A6) — lean reviewer sets; payments → pci.
+    "vertical-saas": ["security-officer"],
+    "booking": ["pci-reviewer", "security-officer"],
+    "crm": ["security-officer"],
+    "dashboard": ["security-officer"],
+    "content-platform": ["pci-reviewer", "security-officer"],
+    "marketplace-lite": ["pci-reviewer", "security-officer"],
     "greenfield": [],
 };
 /**
@@ -1367,6 +1361,14 @@ export const GATES_BY_ARCHETYPE = {
     "gov-public": ["plan", "qa", "gov-review", "security", "ship", "compliance"],
     "insurance": ["plan", "qa", "insurance-review", "security", "ship", "compliance"],
     "defense-govcon": ["plan", "qa", "cmmc-assessment", "security", "ship", "compliance"],
+    // Product Builder archetypes (A1–A6) — non-regulated baseline; the single CTO gate
+    // emerges at change_tier T1 (effectiveGates → [plan]).
+    "vertical-saas": ["plan", "qa", "ship"],
+    "booking": ["plan", "qa", "ship"],
+    "crm": ["plan", "qa", "ship"],
+    "dashboard": ["plan", "qa", "ship"],
+    "content-platform": ["plan", "qa", "ship"],
+    "marketplace-lite": ["plan", "qa", "ship"],
     "greenfield": ["plan"],
 };
 /**
@@ -1386,6 +1388,46 @@ export function gatesFor(archetype, size) {
     // large + enterprise → ensure compliance is included
     return all.includes("compliance") ? all : [...all, "compliance"];
 }
+/** Gates that form the non-negotiable floor for a *regulated* archetype. */
+const FLOOR_GATES = ["security", "compliance", "ship"];
+/**
+ * The human gates the pipeline opens for a change, given its archetype, the
+ * project size, AND the per-change risk tier. Composes with `gatesFor()`:
+ *
+ *  - T2 (default): the full size baseline, with `ship` guaranteed even if a
+ *    small project_size had stripped it. An irreversible change always gets a
+ *    final go/no-go. Nothing is ever removed → fail-safe for an unknown tier.
+ *  - T1: only `plan` (you review intent) PLUS the regulated floor. The standalone
+ *    qa/security-as-ceremony is dropped because CI + tests cover a reversible change.
+ *  - T0: the regulated floor only — for a plain archetype that is the empty set
+ *    (CI is the gate); for a regulated one, security+compliance+ship still fire.
+ *
+ * An archetype is "regulated" iff its baseline contains `security` or `compliance`.
+ * That is what keeps the downgrade sound: a fintech repo cannot ship an
+ * irreversible change unreviewed even when the change is labelled a fix.
+ *
+ * NOTE: change-specific T2 triggers (a migration, a new write-connector, a prod
+ * deploy) are resolved upstream by the classifier, which escalates such a change
+ * to T2 before this function sees it. Here we only map an already-decided tier.
+ */
+export function effectiveGates(archetype, size, tier = "T2") {
+    const base = gatesFor(archetype, size);
+    // T2 (and any unrecognized tier) → full baseline, never downgraded, ship forced.
+    if (tier !== "T0" && tier !== "T1") {
+        return base.includes("ship") ? base : [...base, "ship"];
+    }
+    // Regulated archetypes carry a floor that survives every downgrade.
+    const isRegulated = base.includes("security") || base.includes("compliance");
+    const floor = isRegulated ? base.filter((g) => FLOOR_GATES.includes(g)) : [];
+    if (tier === "T1") {
+        const keep = new Set(floor);
+        if (base.includes("plan"))
+            keep.add("plan");
+        return base.filter((g) => keep.has(g)); // preserve base order
+    }
+    // T0 — maintenance.
+    return floor;
+}
 /**
  * Returns the ordered list of reviewers for an archetype. Empty for
  * `greenfield`. Used by the orchestrator to spawn the right
@@ -1394,3 +1436,26 @@ export function gatesFor(archetype, size) {
 export function reviewersFor(archetype) {
     return REVIEWERS_BY_ARCHETYPE[archetype] ?? [];
 }
+/**
+ * Horizontal builder agents (the "obвязка") wired into the build pipeline per
+ * Product-Builder archetype: integrations + migration + billing are universal (every
+ * SMB product integrates, imports from an incumbent, and is a paid product —
+ * subscription-billing-engineer self-scopes to one-off when there's no subscription).
+ * connector-builder adds to dashboards (ingest), media-pipeline-engineer to content
+ * platforms. geo-routing-engineer and mobile-app-builder are signal-gated in
+ * compileFlow (routing/maps signals; mobile/field signals), not archetype-static.
+ */
+const SMB_BUILD_LAYER = ["app-scaffolder", "auth-engineer"];
+const SMB_OBVYAZKA = ["integrations-engineer", "migration-import-engineer", "subscription-billing-engineer"];
+export const BUILDERS_BY_ARCHETYPE = {
+    "vertical-saas": [...SMB_BUILD_LAYER, ...SMB_OBVYAZKA],
+    "booking": [...SMB_BUILD_LAYER, ...SMB_OBVYAZKA],
+    "crm": [...SMB_BUILD_LAYER, ...SMB_OBVYAZKA],
+    "dashboard": [...SMB_BUILD_LAYER, ...SMB_OBVYAZKA, "connector-builder"],
+    "content-platform": [...SMB_BUILD_LAYER, ...SMB_OBVYAZKA, "media-pipeline-engineer"],
+    "marketplace-lite": [...SMB_BUILD_LAYER, ...SMB_OBVYAZKA],
+};
+/** Builder agents for an archetype (the obвязка layer). Empty for non-SMB archetypes. */
+export function buildersFor(archetype) {
+    return BUILDERS_BY_ARCHETYPE[archetype] ?? [];
+}

package/dist/detect.js

@@ -1129,63 +1129,13 @@ function mineReadmeKeywords(dir) {
         // voice-pack
         "voice", "telephony", "ivr", "tts", "stt", "speech-to-text", "text-to-speech",
         "outbound call", "inbound call", "voice agent",
-        // clinical-pack + clinical-trials-pack
-        "clinical", "patient", "ehr", "emr", "phi", "diagnosis", "diagnos", "triage",
-        "radiolog", "patholog", "samd", "scribe", "telehealth-ai", "medical record",
-        "cds", "clinical decision support",
-        "clinical trial", "ctms", "edc", "epro", "econsent", "esource",
-        "randomization", "rtsm", "irt", "decentralized trial", "ind submission",
-        "21 cfr 11", "cdisc", "sdtm", "adam", "irb",
         // hr-ai-pack
         "recruit", "hiring", "candidate", "resume", "interview", "ats", "talent acquisition",
         "performance review", "workforce scheduling", "employee evaluation", "aedt",
         // api-platform-pack
         "public api", "partner api", "developer portal", "api key", "webhook", "sdk",
         "rest api", "graphql api", "openapi",
-        // lending-pack
-        "loan", "lending", "credit decision", "underwrit", "bnpl", "buy now pay later",
-        "buy-now-pay-later", "payroll advance", "ewa", "line of credit", "fico",
-        "credit score", "fcra", "nmls", "financing", "adverse action",
-        // robotics-pack
-        "robot", "cobot", "manipulator", "end-effector", "amr", "agv", "autonomous mobile",
-        "surgical robot", "ros 2", "ros2", "drone", "uav",
-        // em-fintech-pack
-        "india", "nigeria", "brazil", "indonesia", "philippines", "mexico", "kenya",
-        "m-pesa", "mpesa", "upi", "pix", "gcash", "ovo", "dana", "rbi", "cbn", "bsp",
-        "ojk", "mas", "bcb", "condusef", "cross-border", "remittance", "local rails",
-        // climate-pack
-        "carbon", "emission", "ghg", "mrv", "scope 1", "scope 2", "scope 3", "verra",
-        "gold standard", "puro", "sbti", "cdp", "csrd", "cbam", "ghgrp", "offset",
-        "credit retir", "removal", "biogenic",
-        "dna synthesis", "gene synthesis", "oligonucleotide", "protein design",
-        "esm", "alphafold", "rfdiffusion", "pathogen", "select agent", "gain-of-function",
-        "dual-use", "bsl-3", "bsl-4", "biocontainment", "bwc", "p3co", "igsc", "cloud lab",
-        // drug-discovery-pack
-        "drug discovery", "binding affinity", "admet", "toxicity prediction",
-        "generative chem", "generative protein", "antibody design", "mrna design",
-        "virtual screening", "docking", "fep", "chembl", "bindingdb", "pdbbind",
-        "glp", "gmp", "gxp", "preclinical", "lims", "eln", "annex 11", "alcoa",
-        "lab automation", "robotic biology", "liquid handler", "hamilton", "tecan",
-        "beckman", "opentrons", "plate reader", "sequencer", "hplc", "mass spec", "sila",
-        // digital-health-pack (Wave 4) — keep in sync with packs.ts SIGNALS.keywords
-        "wearable", "apple watch", "apple health", "healthkit", "health connect",
-        "garmin", "samsung health", "google fit", "fitbit", "heart rate", "hrv",
-        "heart rate variability", "spo2", "sleep tracking", "sleep stages",
-        "biometric sensor", "stress score", "activity tracking", "ecg wearable",
-        "mental health", "mental wellness", "wellbeing", "mindfulness ai",
-        "stress detection", "burnout detection", "mood tracking", "anxiety ai",
-        "depression ai", "phq-9", "gad-7", "digital therapeutics", "dtx",
-        "cbt app", "dbt app", "therapy ai", "personalised training",
-        "personalized training", "fitness ai", "nutrition ai",
-        "supplement recommendation", "supplement ai", "diet ai", "meal plan ai",
-        "macro ai", "physician review", "physician hitl", "doctor in the loop",
-        "clinical review workflow", "remote patient monitoring", "rpm", "teleconsultation",
         // US-market packs — keep in sync with packs.ts SIGNALS.keywords
-        // sec-cyber-pack
-        "public company", "publicly traded", "10-k", "10k", "8-k", "8k", "s-1", "ipo",
-        "sec filing", "investor relations", "material incident", "materiality",
-        "incident response", "incident disclosure", "breach notification", "siem",
-        "security operations", "circia", "cisa reporting",
         // adtech-privacy-pack
         "meta pixel", "facebook pixel", "fbevents", "conversions api", "capi",
         "google analytics", "ga4", "google tag manager", "tiktok pixel", "ad pixel",

package/dist/flow.js

@@ -1,7 +1,7 @@
 // flow.ts — compiles all detection outputs into a single user-facing FlowResult.
 // Pure function: no I/O, no side effects.
 // Called by bootstrap.ts (writes FLOW.md) and main.ts (prints summary).
-import { reviewersFor, gatesFor } from "./archetypes.js";
+import { reviewersFor, gatesFor, buildersFor } from "./archetypes.js";
 import { suggestPackReviewers, suggestPackGates, suggestPacks } from "./packs.js";
 import { suggestJurisdictions, suggestJurisdictionReviewers, suggestJurisdictionGates } from "./jurisdictions.js";
 // ── Human-readable titles ─────────────────────────────────────────────────
@@ -31,6 +31,12 @@ const ARCHETYPE_TITLE = {
     "gov-public": "Government",
     "insurance": "Insurance",
     "regulated": "Regulated system",
+    "vertical-saas": "Vertical SaaS",
+    "booking": "Booking / scheduling",
+    "crm": "CRM",
+    "dashboard": "Dashboard / analytics",
+    "content-platform": "Content / media platform",
+    "marketplace-lite": "Marketplace",
     "greenfield": "New project",
 };
 // Gate id (StandardGate) → user label
@@ -76,8 +82,29 @@ const ARCHETYPE_COST = {
     "infra": [3, 8],
     "library": [0.5, 3],
     "cli-tool": [0.5, 3],
+    // Product Builder archetypes — cheap, high-automation builds.
+    "vertical-saas": [3, 8],
+    "booking": [3, 8],
+    "crm": [3, 8],
+    "dashboard": [3, 8],
+    "content-platform": [3, 8],
+    "marketplace-lite": [3, 8],
     "greenfield": [0.5, 3],
 };
+/**
+ * Archetypes that ship a user-facing interface and therefore get a
+ * `design-advisor` stage (plan-altitude, before pm). Backend/infra/library/CLI
+ * archetypes have no UI surface and skip it. design-advisor itself skips a
+ * change classified T0 at runtime (see scripts/lib/change-tier.mjs).
+ */
+export const UI_BEARING_ARCHETYPES = new Set([
+    "web-service", "mobile-app", "commerce", "marketplace", "cms",
+    "enterprise-saas", "edtech", "game", "browser-extension",
+    "healthcare", "fintech", "insurance", "gov-public", "web3",
+    // Product Builder archetypes (A1–A6) — all ship a UI.
+    "vertical-saas", "booking", "crm", "dashboard", "content-platform",
+    "marketplace-lite",
+]);
 // ── Main export ───────────────────────────────────────────────────────────
 /**
  * Compile all detection outputs into a single FlowResult.
@@ -96,6 +123,23 @@ export function compileFlow(archetype, size, detection, compliance, confidence)
     agentSet.add("architect");
     agentSet.add("senior-dev");
     agentSet.add("qa-engineer");
+    // Design-advisor for UI-bearing archetypes (plan-altitude, before pm).
+    if (UI_BEARING_ARCHETYPES.has(archetype))
+        agentSet.add("design-advisor");
+    // Horizontal builder agents (the obвязка) for Product-Builder archetypes.
+    for (const b of buildersFor(archetype))
+        agentSet.add(b);
+    // Signal-gated specialist builders — only when the product actually needs them.
+    const kw = new Set(detection.readmeKeywords.map((k) => k.toLowerCase()));
+    const ROUTING_SIGNALS = ["routing", "route", "dispatch", "delivery", "fleet", "logistics", "maps", "geocode"];
+    if ((archetype === "booking" || archetype === "vertical-saas") &&
+        ROUTING_SIGNALS.some((s) => kw.has(s))) {
+        agentSet.add("geo-routing-engineer");
+    }
+    const MOBILE_SIGNALS = ["mobile", "ios", "android", "react-native", "field", "offline", "technician", "crew"];
+    if (UI_BEARING_ARCHETYPES.has(archetype) && MOBILE_SIGNALS.some((s) => kw.has(s))) {
+        agentSet.add("mobile-app-builder");
+    }
     // ── Gates ────────────────────────────────────────────────────────────────
     const gateSet = new Set(gatesFor(archetype, size).map((g) => GATE_LABEL[g] ?? `gate:${g}`));
     for (const g of suggestPackGates(detection))

package/dist/jurisdictions.js

@@ -3,7 +3,7 @@
 //
 // Three-axis detection model:
 //   archetype  → what you build  (ai-system, healthcare, fintech…)
-//   pack       → what you use    (digital-health-pack, lending-pack…)
+//   pack       → what you use    (…)
 //   jurisdiction → where you operate  (eu, us-ca, in, br, uk, au, sg)
 //
 // Jurisdiction overlays add specialist reviewer agents and human gates

package/dist/land.js

@@ -0,0 +1,60 @@
+// ZRS land-step — the ctx merge-queue borrow: "agent finished" != "change landed".
+// Two gates: (1) apply-clean rebase onto the LIVE target, (2) combined-verify on the rebased
+// result. Advance the target with ff-only ONLY when both pass. Runners are injected so the gates
+// are unit-testable without a real repo (see tests/task-queue.test.mjs).
+import { spawnSync } from "node:child_process";
+export const realRunners = {
+    git(cwd, args) {
+        const r = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf8" });
+        return { code: r.status ?? 1, out: (r.stdout || "") + (r.stderr || "") };
+    },
+    verify(cmd, cwd) {
+        if (!cmd)
+            return 0; // no verify configured → Gate 2 is a no-op (still green)
+        const r = spawnSync("sh", ["-c", cmd], { cwd, stdio: "inherit" });
+        return r.status ?? 1;
+    },
+};
+/**
+ * Land `branch` (built in `worktree`) onto `task.target`. Returns the terminal status.
+ *   needs-revision = Gate 1 conflict (rebase failed) — bounce back for human re-add / agent rebase
+ *   failed         = Gate 2 red (verify non-zero)
+ *   landed         = clean ∧ green, fast-forwarded onto target
+ */
+export function land(task, branch, worktree, runners = realRunners) {
+    const { git, verify } = runners;
+    const target = task.target;
+    // ── Gate 1: rebase the work onto the live target (it may have moved under us) ──
+    const reb = git(worktree, ["rebase", target]);
+    if (reb.code !== 0) {
+        git(worktree, ["rebase", "--abort"]);
+        return { status: "needs-revision", gate1: "conflict", reason: `rebase conflict onto ${target}` };
+    }
+    // ── Gate 2: verify the REBASED (combined) result — A green + B green can still be A+B red ──
+    if (verify(task.verify, worktree) !== 0) {
+        return { status: "failed", gate1: "clean", gate2: "red", reason: "verify failed on rebased result" };
+    }
+    // ── Land: advance target with ff-only (never force, never clobber a concurrent commit) ──
+    if (git(task.repo, ["checkout", target]).code !== 0) {
+        return { status: "failed", gate1: "clean", gate2: "green", reason: `checkout ${target} failed` };
+    }
+    let merged = git(task.repo, ["merge", "--ff-only", branch]);
+    if (merged.code !== 0) {
+        // target moved during verify → re-rebase once, re-verify, retry ff
+        const re = git(worktree, ["rebase", target]);
+        if (re.code !== 0) {
+            git(worktree, ["rebase", "--abort"]);
+            return { status: "needs-revision", gate1: "conflict", gate2: "green", reason: "target moved + conflict" };
+        }
+        if (verify(task.verify, worktree) !== 0) {
+            return { status: "failed", gate1: "clean", gate2: "red", reason: "verify red after re-rebase" };
+        }
+        git(task.repo, ["checkout", target]);
+        merged = git(task.repo, ["merge", "--ff-only", branch]);
+        if (merged.code !== 0) {
+            return { status: "needs-revision", gate1: "clean", gate2: "green", reason: "still not fast-forward after re-rebase" };
+        }
+    }
+    const sha = git(task.repo, ["rev-parse", "--short", "HEAD"]).out.trim();
+    return { status: "landed", gate1: "clean", gate2: "green", commit: sha };
+}

package/dist/main.js

@@ -118,6 +118,16 @@ function parseArgs(argv) {
             args.command = "report";
         else if (a === "upgrade")
             args.command = "upgrade";
+        else if (a === "task") {
+            args.command = "task";
+            args.taskArgs = argv.slice(i + 1);
+            break;
+        }
+        else if (a === "worker") {
+            args.command = "worker";
+            args.taskArgs = argv.slice(i + 1);
+            break;
+        }
         // Slash-commands surfaced as CLI subcommands so users get a clear hint
         // instead of a confusing usage error. These work only in the chat plugin.
         else if (a === "start" || a === "audit" || a === "inbox" || a === "digest" ||
@@ -1154,6 +1164,14 @@ async function main() {
             process.exit(2);
         }
     }
+    if (args.command === "task") {
+        const { runTask } = await import("./worker.js");
+        process.exit(await runTask(args.taskArgs ?? []));
+    }
+    if (args.command === "worker") {
+        const { runWorker } = await import("./worker.js");
+        process.exit(await runWorker(args.taskArgs ?? []));
+    }
     if (args.command === "serve") {
         try {
             const { runServe } = await import("./serve.js");

package/dist/packs.js

@@ -11,33 +11,15 @@
 // skills/great_cto/packs/*-pack.md.
 const PACK_REVIEWERS = {
     "voice-pack": ["voice-ai-reviewer"],
-    "clinical-pack": ["ai-clinical-reviewer", "fda-reviewer"],
     "hr-ai-pack": ["hr-ai-reviewer"],
     "api-platform-pack": ["api-platform-reviewer"],
-    "lending-pack": ["lending-credit-reviewer"],
-    "clinical-trials-pack": ["clinical-trials-reviewer", "bio-data-reviewer"],
-    "robotics-pack": ["robotics-safety-reviewer"],
-    "em-fintech-pack": ["emerging-markets-fintech-reviewer"],
-    "climate-pack": ["climate-mrv-reviewer", "biosecurity-reviewer"],
-    "drug-discovery-pack": ["drug-discovery-ml-reviewer", "glp-glab-reviewer", "lab-automation-reviewer"],
-    "digital-health-pack": ["digital-health-reviewer", "ai-clinical-reviewer", "healthcare-reviewer"],
-    "sec-cyber-pack": ["sec-cyber-disclosure-reviewer"],
     "adtech-privacy-pack": ["adtech-privacy-reviewer", "us-privacy-reviewer"],
     "us-ai-pack": ["us-ai-reviewer"],
 };
 const PACK_GATES = {
     "voice-pack": ["gate:voice-compliance"],
-    "clinical-pack": ["gate:samd-class", "gate:clinical-validation", "gate:ide-approval"],
     "hr-ai-pack": ["gate:aedt-audit"],
     "api-platform-pack": ["gate:api-contract"],
-    "lending-pack": ["gate:fair-lending"],
-    "clinical-trials-pack": ["gate:irb-ready", "gate:part11-validation", "gate:deidentification"],
-    "robotics-pack": ["gate:hara-signoff", "gate:functional-safety-test"],
-    "em-fintech-pack": ["gate:license-strategy"],
-    "climate-pack": ["gate:mrv-methodology", "gate:durc-signoff", "gate:open-weights-release"],
-    "drug-discovery-pack": ["gate:model-card-signoff", "gate:csv-validation", "gate:iq-oq-pq"],
-    "digital-health-pack": ["gate:wellness-vs-samd", "gate:hitl-design", "gate:wearable-api-access", "gate:supplement-safety", "gate:mental-health-protocol"],
-    "sec-cyber-pack": ["gate:cyber-disclosure-readiness"],
     "adtech-privacy-pack": ["gate:tracking-consent"],
     "us-ai-pack": ["gate:ai-governance"],
 };
@@ -47,10 +29,6 @@ const SIGNALS = {
         stack: ["twilio", "vonage", "livekit", "deepgram", "elevenlabs", "whisper", "hume"],
         keywords: ["voice", "telephony", "ivr", "call-center", "tts", "stt", "speech-to-text", "text-to-speech", "phone", "outbound call", "inbound call", "voice agent"],
     },
-    "clinical-pack": {
-        stack: ["fhir", "hl7"],
-        keywords: ["clinical", "patient", "ehr", "emr", "phi", "hipaa", "diagnos", "triage", "radiolog", "patholog", "samd", "scribe", "telehealth-ai", "medical record", "cds", "clinical decision support"],
-    },
     "hr-ai-pack": {
         stack: ["greenhouse", "lever", "ashby", "workday"],
         // "candidate" alone is too generic (SaMD/predicate-candidate clash); use compound terms.
@@ -60,67 +38,6 @@ const SIGNALS = {
         stack: ["openapi", "graphql", "grpc", "fastify", "trpc"],
         keywords: ["public api", "partner api", "developer portal", "api key", "webhook", "sdk", "rest api", "graphql api", "openapi"],
     },
-    "lending-pack": {
-        stack: ["plaid"],
-        // "ecoa" removed: collides with clinical "eCOA" (Electronic Clinical Outcome Assessment).
-        // Lending-specific signals (loan, fcra, nmls, underwrit, fico, ...) are unambiguous.
-        keywords: ["loan", "lending", "credit decision", "underwrit", "bnpl", "buy now pay later", "buy-now-pay-later", "payroll advance", "ewa", "line of credit", "fico", "credit score", "fcra", "nmls", "financing", "adverse action"],
-    },
-    "clinical-trials-pack": {
-        stack: ["fhir", "hl7", "dicom", "redcap"],
-        // "ecoa" removed: ambiguous with lending ECOA (Reg B). Other clinical-trial
-        // signals (ctms, edc, epro, econsent, cdisc, irb, ...) are unambiguous.
-        keywords: ["clinical trial", "ctms", "edc", "epro", "econsent", "esource", "randomization", "rtsm", "irt", "decentralized trial", "ind submission", "21 cfr 11", "cdisc", "sdtm", "adam", "irb"],
-    },
-    "robotics-pack": {
-        stack: ["ros", "ros2", "moveit", "gazebo", "px4"],
-        keywords: ["robot", "cobot", "manipulator", "end-effector", "amr", "agv", "autonomous mobile", "surgical robot", "ros 2", "drone", "uav"],
-    },
-    "em-fintech-pack": {
-        stack: [],
-        keywords: ["india", "nigeria", "brazil", "indonesia", "philippines", "mexico", "kenya", "m-pesa", "mpesa", "upi", "pix", "gcash", "ovo", "dana", "rbi", "cbn", "bsp", "ojk", "mas", "bcb", "condusef", "cross-border", "remittance", "local rails"],
-    },
-    "climate-pack": {
-        stack: [],
-        keywords: ["carbon", "emission", "ghg", "mrv", "scope 1", "scope 2", "scope 3", "verra", "gold standard", "puro", "sbti", "cdp", "csrd", "cbam", "ghgrp", "offset", "credit retir", "removal", "biogenic",
-            // biosec triggers
-            "dna synthesis", "gene synthesis", "oligonucleotide", "protein design", "esm", "alphafold", "rfdiffusion", "pathogen", "select agent", "gain-of-function", "dual-use", "bsl-3", "bsl-4", "biocontainment", "bwc", "p3co", "igsc", "cloud lab"],
-    },
-    "drug-discovery-pack": {
-        stack: ["rdkit"],
-        keywords: ["drug discovery", "binding affinity", "admet", "toxicity prediction", "generative chem", "generative protein", "antibody design", "mrna design", "virtual screening", "docking", "fep", "alphafold", "rfdiffusion", "chembl", "bindingdb", "pdbbind",
-            // GLP / lab-automation triggers
-            "glp", "gmp", "gxp", "preclinical", "lims", "eln", "annex 11", "alcoa",
-            "lab automation", "cloud lab", "robotic biology", "liquid handler", "hamilton", "tecan", "beckman", "opentrons", "plate reader", "sequencer", "hplc", "mass spec", "sila"],
-    },
-    "digital-health-pack": {
-        stack: ["healthkit", "health-connect", "garmin-connect-iq", "samsung-health", "fitbit", "polar", "withings", "oura", "whoop"],
-        keywords: [
-            // wearable / biometric
-            "wearable", "apple watch", "apple health", "healthkit", "health connect", "garmin", "samsung health",
-            "google fit", "fitbit", "heart rate", "hrv", "heart rate variability", "spo2", "sleep tracking",
-            "sleep stages", "biometric sensor", "stress score", "activity tracking", "ecg wearable",
-            // mental health / wellness AI
-            "mental health", "mental wellness", "wellbeing", "mindfulness ai", "stress detection",
-            "burnout detection", "mood tracking", "anxiety ai", "depression ai", "phq-9", "gad-7",
-            "digital therapeutics", "dtx", "cbt app", "dbt app", "therapy ai",
-            // fitness / nutrition AI
-            "personalised training", "personalized training", "fitness ai", "nutrition ai",
-            "supplement recommendation", "supplement ai", "diet ai", "meal plan ai", "macro ai",
-            // HITL clinical
-            "physician review", "physician hitl", "doctor in the loop", "clinical review workflow",
-            "remote patient monitoring", "rpm", "teleconsultation",
-        ],
-    },
-    "sec-cyber-pack": {
-        stack: ["pagerduty", "opsgenie", "statuspage", "splunk", "datadog-siem", "sentinel", "wazuh"],
-        keywords: [
-            "public company", "publicly traded", "10-k", "10k", "8-k", "8k", "s-1", "ipo",
-            "sec filing", "investor relations", "material incident", "materiality",
-            "incident response", "incident disclosure", "breach notification", "siem",
-            "security operations", "soc 2 incident", "circia", "cisa reporting",
-        ],
-    },
     "adtech-privacy-pack": {
         stack: ["fbevents", "facebook-pixel", "meta-pixel", "gtag", "ga4", "google-tag-manager", "gtm", "tiktok-pixel", "fullstory", "hotjar", "logrocket", "mouseflow", "smartlook"],
         keywords: [

package/dist/task-queue.js

@@ -0,0 +1,83 @@
+// ZRS bounded task-runner — queue + worker-owned state (see docs/strategy/ZRS-TASK-RUNNER-DESIGN.md).
+// Producer appends to task-queue.jsonl; the single worker owns task-state.json (atomic rewrite).
+// State lives under ~/.great_cto/ (override with GREAT_CTO_HOME) so a VPS worker is self-contained.
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, renameSync } from "node:fs";
+const ROOT = process.env.GREAT_CTO_HOME || join(homedir(), ".great_cto");
+export const QUEUE = join(ROOT, "task-queue.jsonl");
+export const STATE = join(ROOT, "task-state.json");
+const TERMINAL = new Set(["landed", "failed", "needs-revision", "cancelled"]);
+export function isTerminal(s) { return TERMINAL.has(s); }
+function ensureDir() { mkdirSync(ROOT, { recursive: true }); }
+export function newId(now = Date.now()) {
+    return `t_${Math.floor(now / 1000)}_${Math.random().toString(36).slice(2, 6)}`;
+}
+export function appendTask(t) {
+    ensureDir();
+    const task = {
+        id: t.id ?? newId(),
+        created_at: t.created_at ?? new Date().toISOString(),
+        repo: t.repo,
+        target: t.target || "main",
+        prompt: t.prompt,
+        model: t.model || "sonnet",
+        verify: t.verify ?? "",
+        timeout_s: t.timeout_s || 3600,
+        priority: t.priority || 0,
+    };
+    appendFileSync(QUEUE, JSON.stringify(task) + "\n");
+    return task;
+}
+export function readQueue() {
+    if (!existsSync(QUEUE))
+        return [];
+    return readFileSync(QUEUE, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l));
+}
+export function readState() {
+    if (!existsSync(STATE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(STATE, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeState(s) {
+    ensureDir();
+    const tmp = STATE + ".tmp";
+    writeFileSync(tmp, JSON.stringify(s, null, 2));
+    renameSync(tmp, STATE); // atomic on the same fs
+}
+export function setState(id, patch) {
+    const s = readState();
+    const prev = s[id] ?? { status: "queued", attempts: 0 };
+    s[id] = { ...prev, ...patch };
+    writeState(s);
+    return s[id];
+}
+/** Highest-priority queued task with no (or queued) state. One worker → no claim race beyond this. */
+export function nextRunnable() {
+    const st = readState();
+    const cand = readQueue().filter((t) => {
+        const s = st[t.id];
+        return !s || s.status === "queued";
+    });
+    cand.sort((a, b) => (b.priority - a.priority) || a.created_at.localeCompare(b.created_at));
+    return cand[0] ?? null;
+}
+/** On worker boot, any non-terminal task is a crash remnant → fail it so a restart never double-runs. */
+export function recoverCrashed() {
+    const s = readState();
+    let n = 0;
+    for (const id of Object.keys(s)) {
+        if (!isTerminal(s[id].status)) {
+            s[id] = { ...s[id], status: "failed", reason: "interrupted", ended_at: new Date().toISOString() };
+            n++;
+        }
+    }
+    if (n)
+        writeState(s);
+    return n;
+}

package/dist/telemetry.js

@@ -141,13 +141,15 @@ async function send(evt) {
     catch { /* best-effort */ }
 }
 // --- Public API ------------------------------------------------------------
-/** First-run/install ping. Sent only when enabled. Idempotent across runs. */
+/** First-run/install ping. Sent only when enabled. Idempotent across runs.
+ *  Distinct `command: "install"` (was "init", which conflated installs with the
+ *  init subcommand) so lifetime installs are counted separately from init runs. */
 export async function sendInstallPing(opts) {
     if (!opts.consent)
         return;
     if (!isTelemetryEnabled())
         return;
-    const evt = sanitize({ cliVersion: opts.cliVersion, command: "init", archetype: opts.archetype });
+    const evt = sanitize({ cliVersion: opts.cliVersion, command: "install", archetype: opts.archetype });
     if (!evt)
         return;
     await send(evt);

package/dist/worker.js

@@ -0,0 +1,172 @@
+// ZRS worker — single persistent worker: poll queue → one agent in an isolated worktree → land-step.
+// CLI: `great-cto task add|ls|status|cancel` and `great-cto worker`. See docs/strategy/ZRS-TASK-RUNNER-DESIGN.md.
+import { spawn, spawnSync } from "node:child_process";
+import { createServer } from "node:http";
+import { existsSync, mkdirSync, openSync, writeFileSync, unlinkSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { join, resolve } from "node:path";
+import { appendTask, readQueue, readState, setState, nextRunnable, recoverCrashed, isTerminal, } from "./task-queue.js";
+import { land } from "./land.js";
+const ROOT = process.env.GREAT_CTO_HOME || join(homedir(), ".great_cto");
+const LOGDIR = join(ROOT, "worker-logs");
+const LOCK = join(ROOT, "worker.lock");
+const flagOf = (rest) => (name, def = "") => {
+    const i = rest.indexOf("--" + name);
+    return i >= 0 ? (rest[i + 1] ?? def) : def;
+};
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// ── CLI: great-cto task <add|ls|status|cancel> ──────────────────────────────
+export async function runTask(rest) {
+    const action = rest[0];
+    const flag = flagOf(rest);
+    if (action === "add") {
+        const prompt = rest.slice(1).find((a) => !a.startsWith("--"));
+        if (!prompt) {
+            console.error('usage: great-cto task add "<prompt>" [--repo .] [--target main] [--model sonnet] [--verify "npm test"] [--timeout 3600]');
+            return 1;
+        }
+        const t = appendTask({
+            repo: resolve(flag("repo", process.cwd())),
+            target: flag("target", "main"),
+            prompt,
+            model: flag("model", "sonnet"),
+            verify: flag("verify", ""),
+            timeout_s: parseInt(flag("timeout", "3600"), 10),
+            priority: parseInt(flag("priority", "0"), 10),
+        });
+        console.log("queued " + t.id);
+        return 0;
+    }
+    if (action === "ls") {
+        const st = readState();
+        for (const t of readQueue()) {
+            const s = st[t.id];
+            console.log(`${t.id}  ${(s?.status ?? "queued").padEnd(14)} ${t.prompt.slice(0, 60)}`);
+        }
+        return 0;
+    }
+    if (action === "status") {
+        const s = readState()[rest[1] ?? ""];
+        console.log(s ? JSON.stringify(s, null, 2) : "unknown task");
+        return s ? 0 : 1;
+    }
+    if (action === "cancel") {
+        const id = rest[1] ?? "";
+        const s = readState()[id];
+        if (s && !isTerminal(s.status)) {
+            setState(id, { status: "cancelled", ended_at: new Date().toISOString() });
+            console.log("cancelled " + id);
+            return 0;
+        }
+        console.log("not cancellable");
+        return 1;
+    }
+    console.error("usage: great-cto task <add|ls|status|cancel>");
+    return 1;
+}
+// ── CLI: great-cto worker ───────────────────────────────────────────────────
+export async function runWorker(rest) {
+    const flag = flagOf(rest);
+    const poll = parseInt(flag("poll", "10"), 10) * 1000;
+    const port = parseInt(flag("status-port", "4319"), 10);
+    const once = rest.includes("--once");
+    mkdirSync(LOGDIR, { recursive: true });
+    if (existsSync(LOCK)) {
+        console.error(`worker.lock present — another worker is running (or stale: rm ${LOCK})`);
+        return 1;
+    }
+    writeFileSync(LOCK, String(process.pid));
+    const cleanup = () => { try {
+        unlinkSync(LOCK);
+    }
+    catch { /* ignore */ } };
+    process.on("exit", cleanup);
+    process.on("SIGINT", () => { cleanup(); process.exit(0); });
+    process.on("SIGTERM", () => { cleanup(); process.exit(0); });
+    recoverCrashed();
+    let current = null;
+    const srv = createServer((req, res) => {
+        if (req.url === "/healthz") {
+            res.end("ok");
+            return;
+        }
+        const st = readState();
+        const counts = {};
+        for (const v of Object.values(st))
+            counts[v.status] = (counts[v.status] ?? 0) + 1;
+        res.setHeader("content-type", "application/json");
+        res.end(JSON.stringify({ host: hostname(), worker_pid: process.pid, current, counts, tasks: st }, null, 2));
+    });
+    srv.listen(port, "127.0.0.1");
+    console.log(`great-cto worker up · status http://127.0.0.1:${port}/status · poll ${poll / 1000}s${once ? " · once" : ""}`);
+    for (;;) {
+        const t = nextRunnable();
+        if (!t) {
+            if (once)
+                break;
+            await sleep(poll);
+            continue;
+        }
+        current = t.id;
+        const branch = `zrs/${t.id}`;
+        const wt = join(t.repo, ".worktrees", t.id);
+        setState(t.id, { status: "claimed", branch, worktree: wt, attempts: (readState()[t.id]?.attempts ?? 0) + 1 });
+        const wtAdd = spawnSync("git", ["-C", t.repo, "worktree", "add", wt, "-b", branch, t.target], { encoding: "utf8" });
+        if (wtAdd.status !== 0) {
+            setState(t.id, { status: "failed", reason: "worktree add failed: " + (wtAdd.stderr || "").trim(), ended_at: new Date().toISOString() });
+            current = null;
+            if (once)
+                break;
+            continue;
+        }
+        setState(t.id, { status: "running", started_at: new Date().toISOString() });
+        const log = join(LOGDIR, `${t.id}.log`);
+        const code = await runAgent(t, wt, log);
+        if (code !== 0) {
+            setState(t.id, { status: "failed", reason: "agent exit " + code, ended_at: new Date().toISOString(), log });
+            cleanupWorktree(t.repo, wt);
+            current = null;
+            if (once)
+                break;
+            continue;
+        }
+        setState(t.id, { status: "landing", log });
+        const result = land(t, branch, wt);
+        setState(t.id, { ...result, ended_at: new Date().toISOString(), log });
+        cleanupWorktree(t.repo, wt);
+        current = null;
+        if (once)
+            break;
+    }
+    srv.close();
+    cleanup();
+    return 0;
+}
+function cleanupWorktree(repo, wt) {
+    spawnSync("git", ["-C", repo, "worktree", "remove", wt, "--force"]);
+}
+function runAgent(t, wt, log) {
+    return new Promise((res) => {
+        const out = openSync(log, "a");
+        // GREAT_CTO_AGENT_CMD overrides the spawn (CI / dry-run with a fake agent). PROMPT is exported.
+        const override = process.env.GREAT_CTO_AGENT_CMD;
+        const child = override
+            ? spawn("sh", ["-c", override], { cwd: wt, stdio: ["ignore", out, out], env: { ...process.env, PROMPT: t.prompt } })
+            : spawn("claude", ["-p", t.prompt, "--permission-mode", "acceptEdits", "--model", t.model], {
+                cwd: wt,
+                stdio: ["ignore", out, out],
+            });
+        const timer = setTimeout(() => {
+            try {
+                child.kill("SIGTERM");
+            }
+            catch { /* ignore */ }
+            setTimeout(() => { try {
+                child.kill("SIGKILL");
+            }
+            catch { /* ignore */ } }, 5000);
+        }, t.timeout_s * 1000);
+        child.on("exit", (c) => { clearTimeout(timer); res(c ?? 1); });
+        child.on("error", () => { clearTimeout(timer); res(127); });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "great-cto",
-  "version": "2.73.1",
+  "version": "2.75.0",
   "description": "One command install for the great_cto Claude Code plugin. Auto-detects your stack, picks the right archetype, bootstraps PROJECT.md.",
   "keywords": [
     "claude-code",