sdd-cli 0.1.27 → 0.1.28

package/dist/commands/ai-autopilot.d.ts

@@ -15,5 +15,5 @@ export type ImproveAppResult = {
     fileCount: number;
     reason?: string;
 };
-export declare function bootstrapProjectCode(projectRoot: string, projectName: string, intent: string, providerRequested?: string): CodeBootstrapResult;
-export declare function improveGeneratedApp(appDir: string, intent: string, providerRequested?: string, qualityDiagnostics?: string[]): ImproveAppResult;
+export declare function bootstrapProjectCode(projectRoot: string, projectName: string, intent: string, providerRequested?: string, domainHint?: string): CodeBootstrapResult;
+export declare function improveGeneratedApp(appDir: string, intent: string, providerRequested?: string, qualityDiagnostics?: string[], domainHint?: string): ImproveAppResult;

package/dist/commands/ai-autopilot.js

@@ -180,8 +180,85 @@ function intentSuggestsRelationalDataDomain(intent) {
         "hospital"
     ].some((token) => lower.includes(token));
 }
-function extraPromptConstraints(intent) {
+function detectAutopilotDomain(intent, domainHint) {
+    const hinted = normalizeIntentText(domainHint ?? "");
+    if (hinted === "software" ||
+        hinted === "legal" ||
+        hinted === "business" ||
+        hinted === "humanities" ||
+        hinted === "learning" ||
+        hinted === "design" ||
+        hinted === "data_science" ||
+        hinted === "generic") {
+        return hinted;
+    }
+    const lower = normalizeIntentText(intent);
+    if (/\bcourt\b|\blaw\b|\bpolicy\b|\bcompliance\b|\blawyer\b|\bregulation\b|\bcontract\b/.test(lower))
+        return "legal";
+    if (/\bpricing\b|\bmarket\b|\bforecast\b|\beconomics\b|\baccounting\b|\bfinanzas\b|\bcontador\b/.test(lower))
+        return "business";
+    if (/\bhistory\b|\bsociology\b|\banthropology\b|\bphilosophy\b|\bliterature\b|\bhumanities\b/.test(lower))
+        return "humanities";
+    if (/\blearn\b|\bteach\b|\blesson\b|\bcourse\b|\bstudent\b|\bmentor\b|\bwriter\b|\bescritor\b/.test(lower))
+        return "learning";
+    if (/\blogo\b|\bbrand\b|\blayout\b|\bvisual\b|\bdesign\b/.test(lower))
+        return "design";
+    if (/\bmodel\b|\bdataset\b|\bprediction\b|\bmachine learning\b|\bml\b/.test(lower))
+        return "data_science";
+    if (/\bfeature\b|\bapi\b|\bbackend\b|\bfrontend\b|\bimplement\b|\bdeveloper\b|\bcode\b|\bapp\b|\bweb\b|\bdesktop\b|\bmovil\b|\bmobile\b/.test(lower)) {
+        return "software";
+    }
+    return "generic";
+}
+function domainPromptConstraints(domain) {
+    if (domain === "legal") {
+        return [
+            "Create legal-quality docs: compliance-matrix.md, risk-register.md, and legal-citations.md.",
+            "Compliance docs must define jurisdiction, applicable regulations, controls, and evidence mapping.",
+            "Risk register must include severity, likelihood, mitigation owner, and due date."
+        ];
+    }
+    if (domain === "business") {
+        return [
+            "Create business-quality docs: assumptions.md, sensitivity-analysis.md, and unit-economics.md.",
+            "Unit economics must include numeric metrics (CAC, LTV, margin, break-even or equivalent).",
+            "Sensitivity analysis must include best/base/worst scenarios and trigger thresholds."
+        ];
+    }
+    if (domain === "humanities") {
+        return [
+            "Create humanities-quality docs: methodology.md and sources.md.",
+            "sources.md must include at least 3 primary or high-quality secondary references.",
+            "Methodology must describe scope, analytical lens, limitations, and citation criteria."
+        ];
+    }
+    if (domain === "learning") {
+        return [
+            "Create learning-quality docs: curriculum.md, exercises.md, and references.md.",
+            "Exercises must include expected outcomes and evaluation criteria.",
+            "Curriculum must include modules, objectives, prerequisites, and progression."
+        ];
+    }
+    if (domain === "design") {
+        return [
+            "Create design-quality docs: design-system.md, accessibility.md, and rationale.md.",
+            "accessibility.md must include WCAG-oriented checks and contrast/keyboard validation.",
+            "rationale.md must capture major design decisions and tradeoffs."
+        ];
+    }
+    if (domain === "data_science") {
+        return [
+            "Create data-science quality docs: dataset-schema.md, evaluation-metrics.md, monitoring-plan.md, reproducibility.md.",
+            "evaluation-metrics.md must define baseline, target metrics, and acceptance thresholds.",
+            "monitoring-plan.md must define drift detection and alerting rules."
+        ];
+    }
+    return [];
+}
+function extraPromptConstraints(intent, domainHint) {
     const constraints = [];
+    const domain = detectAutopilotDomain(intent, domainHint);
+    constraints.push(...domainPromptConstraints(domain));
     if (intentRequiresJavaReactFullstack(intent)) {
         constraints.push("Use split structure: backend/ (Java Spring Boot) and frontend/ (React + Vite).");
         constraints.push("Backend must expose REST APIs for users, books, loans, and inventory.");
@@ -1122,7 +1199,7 @@ function enrichDraftWithAI(input, flow, domain, baseDraft, providerRequested) {
 function templateFallbackAllowed() {
     return process.env.SDD_ALLOW_TEMPLATE_FALLBACK === "1" || process.env.SDD_DISABLE_AI_AUTOPILOT === "1";
 }
-function bootstrapProjectCode(projectRoot, projectName, intent, providerRequested) {
+function bootstrapProjectCode(projectRoot, projectName, intent, providerRequested, domainHint) {
     const outputDir = path_1.default.join(projectRoot, "generated-app");
     fs_1.default.mkdirSync(outputDir, { recursive: true });
     if (process.env.SDD_DISABLE_AI_AUTOPILOT === "1") {
@@ -1147,13 +1224,16 @@ function bootstrapProjectCode(projectRoot, projectName, intent, providerRequeste
     let files = [];
     let fallbackReason;
     if (resolution.ok) {
-        const constraints = extraPromptConstraints(intent);
+        const domain = detectAutopilotDomain(intent, domainHint);
+        const constraints = extraPromptConstraints(intent, domainHint);
         const prompt = [
             "Generate a production-lean starter app from user intent.",
             "The project must be executable fully in local development.",
+            `Domain profile: ${domain}.`,
             "Use DummyLocal adapters for integrations (databases, external APIs, queues) so everything runs locally.",
             "Add a schema document named schemas.md with entities, fields, relations, and constraints.",
             "Add regression tests and regression notes/documentation.",
+            "Quality gate is strict: if required artifacts are missing, your output will be rejected and repaired.",
             ...constraints,
             "Do not mix unrelated runtime stacks unless the intent explicitly requests a multi-tier architecture.",
             "Return ONLY valid JSON with this shape:",
@@ -1182,12 +1262,13 @@ function bootstrapProjectCode(projectRoot, projectName, intent, providerRequeste
             }
         }
         if (files.length === 0) {
-            const fallbackConstraints = extraPromptConstraints(intent);
+            const fallbackConstraints = extraPromptConstraints(intent, domainHint);
             const fallbackPrompt = [
                 "Return ONLY valid JSON. No markdown.",
                 "Schema: {\"files\":[{\"path\":\"relative/path\",\"content\":\"...\"}]}",
                 "Generate only essential starter files to run locally with quality-first defaults.",
                 "Must include: README.md, schemas.md, regression notes, and DummyLocal integration docs.",
+                `Domain profile: ${domain}.`,
                 ...fallbackConstraints,
                 `Project: ${projectName}`,
                 `Intent: ${intent}`
@@ -1283,7 +1364,7 @@ function collectProjectFiles(appDir) {
     walk(appDir);
     return output;
 }
-function improveGeneratedApp(appDir, intent, providerRequested, qualityDiagnostics) {
+function improveGeneratedApp(appDir, intent, providerRequested, qualityDiagnostics, domainHint) {
     if (process.env.SDD_DISABLE_AI_AUTOPILOT === "1") {
         return { attempted: false, applied: false, fileCount: 0, reason: "disabled by env" };
     }
@@ -1300,9 +1381,11 @@ function improveGeneratedApp(appDir, intent, providerRequested, qualityDiagnosti
         .filter((line) => line.length > 0)
         .slice(0, 8)
         .map((line) => (line.length > 280 ? `${line.slice(0, 280)}...[truncated]` : line));
-    const constraints = extraPromptConstraints(intent);
+    const domain = detectAutopilotDomain(intent, domainHint);
+    const constraints = extraPromptConstraints(intent, domainHint);
     const prompt = [
         "Improve this generated app to production-lean quality.",
+        `Domain profile: ${domain}.`,
         "Requirements:",
         "- Keep app intent and behavior.",
         "- Ensure tests pass for the selected stack.",
@@ -1327,6 +1410,7 @@ function improveGeneratedApp(appDir, intent, providerRequested, qualityDiagnosti
             'Schema: {"files":[{"path":"relative/path","content":"..."}]}',
             "Fix exactly the listed quality diagnostics with minimal file edits.",
             "If diagnostics mention missing docs/tests, generate them.",
+            `Domain profile: ${domain}.`,
             `Intent: ${intent}`,
             `Quality diagnostics: ${JSON.stringify(compactDiagnostics)}`,
             `Current file names: ${JSON.stringify(fileNames)}`
@@ -1339,6 +1423,7 @@ function improveGeneratedApp(appDir, intent, providerRequested, qualityDiagnosti
             'Schema: {"files":[{"path":"relative/path","content":"..."}]}',
             "Apply minimal patch set: 1 to 5 files only.",
             "Prioritize fixing the first quality diagnostic immediately.",
+            `Domain profile: ${domain}.`,
             `Intent: ${intent}`,
             `Top quality diagnostics: ${JSON.stringify(compactDiagnostics.slice(0, 2))}`
         ].join("\n");

package/dist/commands/app-lifecycle.d.ts

@@ -6,6 +6,8 @@ type RepoMetadata = {
 export type LifecycleContext = {
     goalText?: string;
     intentSignals?: string[];
+    intentDomain?: string;
+    intentFlow?: string;
 };
 declare function tokenizeIntent(input: string): string[];
 declare function deriveRepoMetadata(projectName: string, appDir: string, context?: LifecycleContext): RepoMetadata;

package/dist/commands/app-lifecycle.js

@@ -211,6 +211,138 @@ function parseGoalProfile(context) {
         relationalDataApp
     };
 }
+function parseDomainProfile(context) {
+    const hinted = normalizeText(context?.intentDomain ?? "");
+    if (hinted === "software" ||
+        hinted === "legal" ||
+        hinted === "business" ||
+        hinted === "humanities" ||
+        hinted === "learning" ||
+        hinted === "design" ||
+        hinted === "data_science" ||
+        hinted === "generic") {
+        return hinted;
+    }
+    const goal = normalizeText(context?.goalText ?? "");
+    if (!goal) {
+        return "generic";
+    }
+    if (/\bcourt\b|\blaw\b|\bpolicy\b|\bcompliance\b|\blawyer\b|\bregulation\b|\bcontract\b|\bjuridic/.test(goal)) {
+        return "legal";
+    }
+    if (/\bpricing\b|\bmarket\b|\bforecast\b|\beconomics\b|\baccounting\b|\bfinanzas\b|\bcontador\b/.test(goal)) {
+        return "business";
+    }
+    if (/\bhistory\b|\bsociology\b|\banthropology\b|\bphilosophy\b|\bliterature\b|\bhumanities\b/.test(goal)) {
+        return "humanities";
+    }
+    if (/\blearn\b|\bteach\b|\blesson\b|\bcourse\b|\bstudent\b|\bmentor\b|\bwriter\b|\bescritor\b/.test(goal)) {
+        return "learning";
+    }
+    if (/\blogo\b|\bbrand\b|\blayout\b|\bvisual\b|\bdesign\b/.test(goal)) {
+        return "design";
+    }
+    if (/\bmodel\b|\bdataset\b|\bprediction\b|\bmachine learning\b|\bml\b|\bai\b/.test(goal)) {
+        return "data_science";
+    }
+    if (/\bapi\b|\bbackend\b|\bfrontend\b|\bapp\b|\bweb\b|\bdesktop\b|\bmobile\b|\breact\b|\bjava\b/.test(goal)) {
+        return "software";
+    }
+    return "generic";
+}
+function countListLikeItems(raw) {
+    return raw
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => /^[-*]\s+/.test(line) || /^\d+\.\s+/.test(line)).length;
+}
+function checkDomainArtifacts(appDir, context) {
+    const profile = parseDomainProfile(context);
+    if (profile === "software" || profile === "generic") {
+        return { ok: true };
+    }
+    const findDoc = (patterns) => findFileRecursive(appDir, (rel) => rel.endsWith(".md") && patterns.some((pattern) => pattern.test(rel)), 10);
+    const readDoc = (rel) => {
+        if (!rel)
+            return "";
+        try {
+            return normalizeText(fs_1.default.readFileSync(path_1.default.join(appDir, rel), "utf-8"));
+        }
+        catch {
+            return "";
+        }
+    };
+    if (profile === "legal") {
+        const compliance = findDoc([/compliance/, /regulation/, /policy/]);
+        const risk = findDoc([/risk/, /risk-register/]);
+        const evidence = findDoc([/citation/, /reference/, /sources/, /precedent/]);
+        if (!compliance || !risk || !evidence) {
+            return { ok: false, reason: "Missing legal artifacts (need compliance, risk-register, and references/citations docs)." };
+        }
+        const complianceText = readDoc(compliance);
+        if (!/\bjurisdiction\b|\bregion\b|\bcountry\b|\blaw\b|\bregulation\b/.test(complianceText)) {
+            return { ok: false, reason: "Legal compliance doc must define jurisdiction and applicable law/regulation scope." };
+        }
+        return { ok: true };
+    }
+    if (profile === "business") {
+        const assumptions = findDoc([/assumption/, /supuesto/]);
+        const sensitivity = findDoc([/sensitivity/, /scenario/, /escenario/]);
+        const economics = findDoc([/unit-economics/, /economics/, /forecast/, /financial/, /cashflow/, /p&l/]);
+        if (!assumptions || !sensitivity || !economics) {
+            return { ok: false, reason: "Missing business artifacts (need assumptions, sensitivity/scenarios, and economics/forecast docs)." };
+        }
+        const economicsText = readDoc(economics);
+        if (!/\b\d/.test(economicsText)) {
+            return { ok: false, reason: "Business economics/forecast doc should include at least one numeric metric or target." };
+        }
+        return { ok: true };
+    }
+    if (profile === "humanities") {
+        const methodology = findDoc([/methodology/, /approach/, /metodologia/]);
+        const sources = findDoc([/sources/, /reference/, /bibliography/, /citations/]);
+        if (!methodology || !sources) {
+            return { ok: false, reason: "Missing humanities artifacts (need methodology and sources/bibliography docs)." };
+        }
+        const sourcesText = readDoc(sources);
+        if (countListLikeItems(sourcesText) < 3) {
+            return { ok: false, reason: "Humanities source quality too low (expected at least 3 listed sources)." };
+        }
+        return { ok: true };
+    }
+    if (profile === "learning") {
+        const curriculum = findDoc([/curriculum/, /outline/, /syllabus/, /plan/]);
+        const exercises = findDoc([/exercise/, /assessment/, /practice/, /rubric/]);
+        const references = findDoc([/sources/, /references/, /reading/, /bibliography/]);
+        if (!curriculum || !exercises || !references) {
+            return { ok: false, reason: "Missing learning artifacts (need curriculum/outline, exercises/assessment, and references)." };
+        }
+        return { ok: true };
+    }
+    if (profile === "design") {
+        const designSystem = findDoc([/design-system/, /style-guide/, /brand/, /ui-kit/]);
+        const accessibility = findDoc([/accessibility/, /a11y/, /wcag/]);
+        const rationale = findDoc([/rationale/, /decision/, /tradeoff/]);
+        if (!designSystem || !accessibility || !rationale) {
+            return { ok: false, reason: "Missing design artifacts (need design-system/style-guide, accessibility, and rationale docs)." };
+        }
+        return { ok: true };
+    }
+    if (profile === "data_science") {
+        const dataDict = findDoc([/dataset/, /schema/, /data-dictionary/]);
+        const evaluation = findDoc([/evaluation/, /metrics/, /benchmark/]);
+        const monitoring = findDoc([/monitoring/, /drift/, /alert/]);
+        const reproducibility = findDoc([/reproducibility/, /experiment/, /runbook/]);
+        if (!dataDict || !evaluation || !monitoring || !reproducibility) {
+            return {
+                ok: false,
+                reason: "Missing data science artifacts (need dataset schema, evaluation metrics, monitoring/drift plan, and reproducibility docs)."
+            };
+        }
+        return { ok: true };
+    }
+    return { ok: true };
+}
 function basicQualityCheck(appDir) {
     const required = ["README.md"];
     const missing = required.filter((name) => !fs_1.default.existsSync(path_1.default.join(appDir, name)));
@@ -502,6 +634,14 @@ function advancedQualityCheck(appDir, context) {
             output: "Missing regression testing evidence (regression doc or tests)"
         };
     }
+    const domainArtifacts = checkDomainArtifacts(appDir, context);
+    if (!domainArtifacts.ok) {
+        return {
+            ok: false,
+            command: "advanced-quality-check",
+            output: domainArtifacts.reason || "Domain artifact quality check failed"
+        };
+    }
     const goalText = context?.goalText?.trim();
     if (goalText) {
         const readmeRaw = fs_1.default.readFileSync(readmePath, "utf-8");

package/dist/commands/digital-reviewers.d.ts

@@ -0,0 +1,13 @@
+import type { LifecycleContext } from "./app-lifecycle";
+type ReviewerFinding = {
+    reviewer: string;
+    severity: "high" | "medium";
+    message: string;
+};
+export type DigitalReviewResult = {
+    passed: boolean;
+    findings: ReviewerFinding[];
+    diagnostics: string[];
+};
+export declare function runDigitalHumanReview(appDir: string, context?: LifecycleContext): DigitalReviewResult;
+export {};

package/dist/commands/digital-reviewers.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDigitalHumanReview = runDigitalHumanReview;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function normalizeText(input) {
+    return input
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "");
+}
+function collectFilesRecursive(root, maxDepth = 8) {
+    const results = [];
+    const walk = (current, depth) => {
+        if (depth > maxDepth)
+            return;
+        for (const entry of fs_1.default.readdirSync(current, { withFileTypes: true })) {
+            const full = path_1.default.join(current, entry.name);
+            const rel = path_1.default.relative(root, full).replace(/\\/g, "/");
+            if (entry.isDirectory()) {
+                if ([".git", "node_modules", "dist", "build", "target", "__pycache__", ".venv", "venv"].includes(entry.name)) {
+                    continue;
+                }
+                walk(full, depth + 1);
+            }
+            else {
+                results.push(rel);
+            }
+        }
+    };
+    walk(root, 0);
+    return results;
+}
+function countTests(root) {
+    if (!fs_1.default.existsSync(root))
+        return 0;
+    const files = collectFilesRecursive(root, 10).filter((rel) => /\.(jsx?|tsx?|py|java)$/i.test(rel));
+    let count = 0;
+    for (const rel of files) {
+        const full = path_1.default.join(root, rel);
+        const raw = fs_1.default.readFileSync(full, "utf-8");
+        if (/\.py$/i.test(rel))
+            count += (raw.match(/\bdef\s+test_/g) || []).length;
+        else if (/\.java$/i.test(rel))
+            count += (raw.match(/@Test\b/g) || []).length;
+        else if (/\.test\.|\.spec\.|__tests__\//i.test(rel))
+            count += (raw.match(/\b(test|it)\s*\(/g) || []).length;
+    }
+    return count;
+}
+function detectDomain(context) {
+    const hinted = normalizeText(context?.intentDomain ?? "");
+    if (hinted)
+        return hinted;
+    const goal = normalizeText(context?.goalText ?? "");
+    if (/\bcourt\b|\blaw\b|\bcompliance\b|\bcontract\b/.test(goal))
+        return "legal";
+    if (/\bpricing\b|\bmarket\b|\bforecast\b|\beconomics\b/.test(goal))
+        return "business";
+    if (/\bhistory\b|\bhumanities\b|\bphilosophy\b/.test(goal))
+        return "humanities";
+    if (/\blearn\b|\bcourse\b|\blesson\b|\bteach\b/.test(goal))
+        return "learning";
+    if (/\bdesign\b|\blogo\b|\bbrand\b/.test(goal))
+        return "design";
+    if (/\bmodel\b|\bdataset\b|\bprediction\b|\bmachine learning\b|\bml\b/.test(goal))
+        return "data_science";
+    return "software";
+}
+function findDoc(root, names) {
+    const files = collectFilesRecursive(root, 8).filter((rel) => rel.endsWith(".md")).map((rel) => rel.toLowerCase());
+    for (const name of names) {
+        const normalized = name.toLowerCase();
+        const found = files.find((rel) => rel === normalized || rel.endsWith(`/${normalized}`) || rel.includes(normalized));
+        if (found)
+            return found;
+    }
+    return null;
+}
+function hasRunbookLikeReadme(readme) {
+    return /\b(run|start|setup|install)\b/.test(readme);
+}
+function hasUserFlowDocs(root, readme) {
+    if (/\buser flow\b|\bux\b|\bexperience\b|\bjourney\b/.test(readme)) {
+        return true;
+    }
+    return Boolean(findDoc(root, ["user-flow.md", "ux-notes.md", "experience.md"]));
+}
+function hasSecretLeak(root) {
+    const files = collectFilesRecursive(root, 8).filter((rel) => /\.(env|txt|md|json|yml|yaml|properties|ts|js|py|java)$/i.test(rel));
+    const patterns = [/api[_-]?key\s*[:=]\s*[^\s]+/i, /secret\s*[:=]\s*[^\s]+/i, /password\s*[:=]\s*[^\s]+/i];
+    for (const rel of files) {
+        const raw = fs_1.default.readFileSync(path_1.default.join(root, rel), "utf-8");
+        if (patterns.some((pattern) => pattern.test(raw)))
+            return true;
+    }
+    return false;
+}
+function runDigitalHumanReview(appDir, context) {
+    const findings = [];
+    if (!fs_1.default.existsSync(appDir)) {
+        return {
+            passed: false,
+            findings: [{ reviewer: "program_manager", severity: "high", message: "Generated app directory is missing." }],
+            diagnostics: ["[DigitalReviewer:program_manager][high] Generated app directory is missing."]
+        };
+    }
+    const readmePath = path_1.default.join(appDir, "README.md");
+    const readme = fs_1.default.existsSync(readmePath) ? normalizeText(fs_1.default.readFileSync(readmePath, "utf-8")) : "";
+    const totalTests = countTests(appDir);
+    const domain = detectDomain(context);
+    if (!readme) {
+        findings.push({ reviewer: "program_manager", severity: "high", message: "README.md is missing; delivery is not product-ready." });
+    }
+    else {
+        if (!/\bfeatures?\b/.test(readme)) {
+            findings.push({ reviewer: "program_manager", severity: "medium", message: "README must include explicit product features section." });
+        }
+        if (!hasRunbookLikeReadme(readme)) {
+            findings.push({ reviewer: "program_manager", severity: "high", message: "README lacks clear execution instructions (run/start/setup/install)." });
+        }
+    }
+    if (totalTests < 8) {
+        findings.push({
+            reviewer: "qa_engineer",
+            severity: "high",
+            message: `Automated test depth is low (${totalTests}). Minimum expected is 8 tests for acceptance.`
+        });
+    }
+    if (!hasUserFlowDocs(appDir, readme)) {
+        findings.push({
+            reviewer: "ux_researcher",
+            severity: "medium",
+            message: "User experience flow is unclear. Add user-flow/UX notes and acceptance of critical journeys."
+        });
+    }
+    if (hasSecretLeak(appDir)) {
+        findings.push({
+            reviewer: "security_reviewer",
+            severity: "high",
+            message: "Potential secret leakage detected (api key/secret/password pattern). Remove hardcoded secrets."
+        });
+    }
+    if (domain === "legal") {
+        if (!findDoc(appDir, ["compliance-matrix.md", "compliance.md"])) {
+            findings.push({ reviewer: "compliance_officer", severity: "high", message: "Legal project requires compliance matrix documentation." });
+        }
+        if (!findDoc(appDir, ["risk-register.md", "legal-risks.md"])) {
+            findings.push({ reviewer: "compliance_officer", severity: "high", message: "Legal project requires risk register with mitigations." });
+        }
+    }
+    if (domain === "business") {
+        if (!findDoc(appDir, ["unit-economics.md", "economics.md", "financial-forecast.md"])) {
+            findings.push({ reviewer: "business_analyst", severity: "high", message: "Business project requires unit-economics or financial forecast documentation." });
+        }
+        if (!findDoc(appDir, ["sensitivity-analysis.md", "scenario-analysis.md"])) {
+            findings.push({ reviewer: "business_analyst", severity: "medium", message: "Business project should include sensitivity/scenario analysis." });
+        }
+    }
+    if (domain === "data_science") {
+        if (!findDoc(appDir, ["evaluation-metrics.md", "metrics.md"])) {
+            findings.push({ reviewer: "ml_reviewer", severity: "high", message: "Data-science delivery requires evaluation metrics documentation." });
+        }
+        if (!findDoc(appDir, ["monitoring-plan.md", "drift-monitoring.md"])) {
+            findings.push({ reviewer: "ml_reviewer", severity: "high", message: "Data-science delivery requires drift monitoring plan." });
+        }
+    }
+    const diagnostics = findings.map((finding) => `[DigitalReviewer:${finding.reviewer}][${finding.severity}] ${finding.message}`);
+    return {
+        passed: findings.length === 0,
+        findings,
+        diagnostics
+    };
+}

package/dist/commands/hello.js

@@ -21,6 +21,7 @@ const local_metrics_1 = require("../telemetry/local-metrics");
 const errors_1 = require("../errors");
 const ai_autopilot_1 = require("./ai-autopilot");
 const app_lifecycle_1 = require("./app-lifecycle");
+const digital_reviewers_1 = require("./digital-reviewers");
 const autopilot_checkpoint_1 = require("./autopilot-checkpoint");
 function printStep(step, description) {
     console.log(`${step}: ${description}`);
@@ -398,7 +399,7 @@ async function runHello(input, runQuestions) {
                 }
                 (0, autopilot_checkpoint_1.clearCheckpoint)(activeProject);
                 const projectRoot = path_1.default.resolve(finished.doneDir, "..", "..", "..");
-                const codeBootstrap = (0, ai_autopilot_1.bootstrapProjectCode)(projectRoot, activeProject, text, provider);
+                const codeBootstrap = (0, ai_autopilot_1.bootstrapProjectCode)(projectRoot, activeProject, text, provider, intent.domain);
                 if (!codeBootstrap.generated) {
                     printWhy(`Code generation blocked: ${codeBootstrap.reason || "provider did not return valid files"}.`);
                     printWhy("No template fallback was applied. Re-run with clearer prompt or improve provider response contract.");
@@ -411,7 +412,9 @@ async function runHello(input, runQuestions) {
                 }
                 let lifecycle = (0, app_lifecycle_1.runAppLifecycle)(projectRoot, activeProject, {
                     goalText: text,
-                    intentSignals: intent.signals
+                    intentSignals: intent.signals,
+                    intentDomain: intent.domain,
+                    intentFlow: intent.flow
                 });
                 lifecycle.summary.forEach((line) => printWhy(`Lifecycle: ${line}`));
                 const lifecycleDisabled = process.env.SDD_DISABLE_APP_LIFECYCLE === "1";
@@ -422,12 +425,14 @@ async function runHello(input, runQuestions) {
                     printWhy("Quality gates failed. Attempting AI repair iterations.");
                     lifecycle.qualityDiagnostics.forEach((issue) => printWhy(`Quality issue: ${issue}`));
                     for (let attempt = 1; attempt <= maxRepairAttempts && !lifecycle.qualityPassed; attempt += 1) {
-                        const repair = (0, ai_autopilot_1.improveGeneratedApp)(appDir, text, provider, lifecycle.qualityDiagnostics);
+                        const repair = (0, ai_autopilot_1.improveGeneratedApp)(appDir, text, provider, lifecycle.qualityDiagnostics, intent.domain);
                         if (repair.attempted && repair.applied) {
                             printWhy(`AI repair attempt ${attempt} applied (${repair.fileCount} files). Re-running lifecycle checks.`);
                             lifecycle = (0, app_lifecycle_1.runAppLifecycle)(projectRoot, activeProject, {
                                 goalText: text,
-                                intentSignals: intent.signals
+                                intentSignals: intent.signals,
+                                intentDomain: intent.domain,
+                                intentFlow: intent.flow
                             });
                             lifecycle.summary.forEach((line) => printWhy(`Lifecycle (retry ${attempt}): ${line}`));
                         }
@@ -441,6 +446,68 @@ async function runHello(input, runQuestions) {
                         return;
                     }
                 }
+                const digitalReviewDisabled = lifecycleDisabled || process.env.SDD_DISABLE_AI_AUTOPILOT === "1" || process.env.SDD_DISABLE_DIGITAL_REVIEW === "1";
+                if (!digitalReviewDisabled) {
+                    const appDir = path_1.default.join(projectRoot, "generated-app");
+                    const parsedReviewAttempts = Number.parseInt(process.env.SDD_DIGITAL_REVIEW_MAX_ATTEMPTS ?? "", 10);
+                    const maxReviewAttempts = Number.isFinite(parsedReviewAttempts) && parsedReviewAttempts > 0 ? parsedReviewAttempts : 3;
+                    let review = (0, digital_reviewers_1.runDigitalHumanReview)(appDir, {
+                        goalText: text,
+                        intentSignals: intent.signals,
+                        intentDomain: intent.domain,
+                        intentFlow: intent.flow
+                    });
+                    if (!review.passed) {
+                        printWhy("Digital human reviewers found delivery issues. Applying targeted refinements.");
+                        review.diagnostics.forEach((issue) => printWhy(`Reviewer issue: ${issue}`));
+                    }
+                    for (let attempt = 1; attempt <= maxReviewAttempts && !review.passed; attempt += 1) {
+                        const repair = (0, ai_autopilot_1.improveGeneratedApp)(appDir, text, provider, review.diagnostics, intent.domain);
+                        if (!repair.attempted || !repair.applied) {
+                            printWhy(`Digital-review repair attempt ${attempt} skipped: ${repair.reason || "unknown reason"}`);
+                            break;
+                        }
+                        printWhy(`Digital-review repair attempt ${attempt} applied (${repair.fileCount} files).`);
+                        lifecycle = (0, app_lifecycle_1.runAppLifecycle)(projectRoot, activeProject, {
+                            goalText: text,
+                            intentSignals: intent.signals,
+                            intentDomain: intent.domain,
+                            intentFlow: intent.flow
+                        });
+                        lifecycle.summary.forEach((line) => printWhy(`Lifecycle (digital-review retry ${attempt}): ${line}`));
+                        if (!lifecycle.qualityPassed) {
+                            const qualityRepair = (0, ai_autopilot_1.improveGeneratedApp)(appDir, text, provider, lifecycle.qualityDiagnostics, intent.domain);
+                            if (qualityRepair.attempted && qualityRepair.applied) {
+                                printWhy(`Quality regression repaired after digital review (${qualityRepair.fileCount} files). Re-validating delivery.`);
+                                lifecycle = (0, app_lifecycle_1.runAppLifecycle)(projectRoot, activeProject, {
+                                    goalText: text,
+                                    intentSignals: intent.signals,
+                                    intentDomain: intent.domain,
+                                    intentFlow: intent.flow
+                                });
+                            }
+                        }
+                        if (!lifecycle.qualityPassed) {
+                            printWhy("Delivery regressed below lifecycle quality gates during digital-review iteration.");
+                            continue;
+                        }
+                        review = (0, digital_reviewers_1.runDigitalHumanReview)(appDir, {
+                            goalText: text,
+                            intentSignals: intent.signals,
+                            intentDomain: intent.domain,
+                            intentFlow: intent.flow
+                        });
+                        if (!review.passed) {
+                            review.diagnostics.forEach((issue) => printWhy(`Reviewer issue (retry ${attempt}): ${issue}`));
+                        }
+                    }
+                    if (!review.passed) {
+                        printWhy("Digital-review quality bar not met after refinement attempts.");
+                        printRecoveryNext(activeProject, "finish", text);
+                        return;
+                    }
+                    printWhy("Digital reviewers approved delivery quality.");
+                }
                 (0, local_metrics_1.recordActivationMetric)("completed", {
                     project: activeProject,
                     reqId

package/dist/commands/req-start.js

@@ -13,6 +13,43 @@ const render_1 = require("../templates/render");
 const list_1 = require("../utils/list");
 const validate_1 = require("../validation/validate");
 const errors_1 = require("../errors");
+function domainQualityProfiles(domain) {
+    const normalized = (domain || "software").trim().toLowerCase();
+    const common = ["single-responsibility", "tests-for-critical-flows", "clear-documentation", "explicit-tradeoffs"];
+    if (normalized === "legal") {
+        return {
+            legal: [...common, "compliance-matrix-required", "risk-register-required", "jurisdiction-defined", "citations-required"]
+        };
+    }
+    if (normalized === "business") {
+        return {
+            business: [...common, "assumptions-log-required", "sensitivity-analysis-required", "numeric-kpi-thresholds-required"]
+        };
+    }
+    if (normalized === "humanities") {
+        return {
+            humanities: [...common, "methodology-required", "source-quality-minimum", "limitations-documented"]
+        };
+    }
+    if (normalized === "learning") {
+        return {
+            learning: [...common, "curriculum-required", "assessment-rubric-required", "references-required"]
+        };
+    }
+    if (normalized === "design") {
+        return {
+            design: [...common, "design-system-required", "accessibility-checks-required", "rationale-required"]
+        };
+    }
+    if (normalized === "data_science") {
+        return {
+            data_science: [...common, "dataset-schema-required", "evaluation-metrics-required", "monitoring-and-drift-plan-required", "reproducibility-required"]
+        };
+    }
+    return {
+        software: [...common, "api-contracts-defined", "telemetry-baseline", "regression-suite-required"]
+    };
+}
 function findRequirementDir(projectRoot, reqId) {
     const backlog = path_1.default.join(projectRoot, "requirements", "backlog", reqId);
     const wip = path_1.default.join(projectRoot, "requirements", "wip", reqId);
@@ -108,10 +145,23 @@ async function runReqStart(options) {
         const qualityTemplate = (0, render_1.loadTemplate)("quality");
         fs_1.default.writeFileSync(qualityPath, qualityTemplate, "utf-8");
     }
+    const metadataPath = path_1.default.join(project.root, "metadata.json");
+    let domain = "software";
+    if (fs_1.default.existsSync(metadataPath)) {
+        try {
+            const metadata = JSON.parse(fs_1.default.readFileSync(metadataPath, "utf-8"));
+            if (typeof metadata.domain === "string" && metadata.domain.trim()) {
+                domain = metadata.domain.trim();
+            }
+        }
+        catch {
+            // keep default
+        }
+    }
     const qualityJson = {
         rules: ["single-responsibility", "tests-for-critical-flows"],
         thresholds: { coverage: "80%", complexity: "10" },
-        profiles: {}
+        profiles: domainQualityProfiles(domain)
     };
     const validation = (0, validate_1.validateJson)("quality.schema.json", qualityJson);
     if (!validation.valid) {

package/dist/router/intent.js

@@ -60,13 +60,13 @@ const SIGNALS = [
 exports.FLOW_PROMPT_PACKS = {
     BUG_FIX: ["discovery.core", "bug_fix.core"],
     PR_REVIEW: ["pr_review.core", "review.severity"],
-    SOFTWARE_FEATURE: ["discovery.core", "release.rollout"],
-    DATA_SCIENCE: ["discovery.core", "data.monitoring"],
-    DESIGN: ["discovery.core", "design.accessibility"],
-    HUMANITIES: ["discovery.core", "humanities.sources"],
-    BUSINESS: ["discovery.core", "business.sensitivity"],
-    LEGAL: ["discovery.core", "legal.compliance"],
-    LEARN: ["discovery.core", "learn.format"],
+    SOFTWARE_FEATURE: ["discovery.core", "release.rollout", "software.quality"],
+    DATA_SCIENCE: ["discovery.core", "data.monitoring", "data.quality"],
+    DESIGN: ["discovery.core", "design.accessibility", "design.quality"],
+    HUMANITIES: ["discovery.core", "humanities.sources", "humanities.quality"],
+    BUSINESS: ["discovery.core", "business.sensitivity", "business.quality"],
+    LEGAL: ["discovery.core", "legal.compliance", "legal.quality"],
+    LEARN: ["discovery.core", "learn.format", "learning.quality"],
     GENERIC: ["discovery.core"]
 };
 function classifyIntent(input) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdd-cli",
-  "version": "0.1.27",
+  "version": "0.1.28",
   "description": "AI-orchestrated specification-driven delivery CLI that plans, validates, and ships production-ready software projects.",
   "keywords": [
     "cli",

package/templates/prompt-pack-index.json

@@ -122,6 +122,83 @@
       "gates": [
         "learning_format_defined"
       ]
+    },
+    {
+      "id": "software.quality",
+      "questions": [
+        "What architecture quality controls are mandatory (DTOs, interfaces, telemetry, security checks)?",
+        "What CI quality thresholds are mandatory (tests, lint, build, coverage)?"
+      ],
+      "gates": [
+        "software_quality_controls_defined",
+        "ci_thresholds_defined"
+      ]
+    },
+    {
+      "id": "legal.quality",
+      "questions": [
+        "Which jurisdiction(s) and legal frameworks apply?",
+        "Which mandatory legal artifacts are required (compliance matrix, risk register, citations)?"
+      ],
+      "gates": [
+        "jurisdiction_defined",
+        "legal_artifacts_defined"
+      ]
+    },
+    {
+      "id": "business.quality",
+      "questions": [
+        "Which assumptions must be explicitly tracked?",
+        "Which unit economics and sensitivity thresholds must be satisfied?"
+      ],
+      "gates": [
+        "assumptions_defined",
+        "financial_thresholds_defined"
+      ]
+    },
+    {
+      "id": "humanities.quality",
+      "questions": [
+        "Which methodology and source-quality standards are required?",
+        "How will source limitations and bias be documented?"
+      ],
+      "gates": [
+        "methodology_defined",
+        "source_quality_and_limits_defined"
+      ]
+    },
+    {
+      "id": "learning.quality",
+      "questions": [
+        "What curriculum structure and progression model are required?",
+        "What assessment and rubric standards must be met?"
+      ],
+      "gates": [
+        "curriculum_defined",
+        "assessment_defined"
+      ]
+    },
+    {
+      "id": "design.quality",
+      "questions": [
+        "Which design-system and accessibility standards are required?",
+        "How should design rationale and tradeoffs be captured?"
+      ],
+      "gates": [
+        "design_system_defined",
+        "design_rationale_defined"
+      ]
+    },
+    {
+      "id": "data.quality",
+      "questions": [
+        "What dataset schema and data-quality rules are required?",
+        "What model evaluation, drift monitoring, and reproducibility standards apply?"
+      ],
+      "gates": [
+        "data_schema_defined",
+        "ml_quality_controls_defined"
+      ]
     }
   ]
 }