gaslighting-engine 0.1.0

package/README.md

@@ -0,0 +1,200 @@
+# Gaslighting-engine
+
+```txt
+ _       _   _  ____   ____ ___
+| |     | | | ||  _ \ / ___|_ _|
+| |     | | | || | | | |  _ | |
+| |___  | |_| || |_| | |_| || |
+|_____|  \___/ |____/ \____|___|
+```
+
+AI coding agents love to escape.
+
+They start strong, then drift.
+
+They implement three examples and call it done.
+
+They leave TODOs.
+
+They create placeholders.
+
+They say "the rest follows the same pattern."
+
+Gaslighting-engine is a strict project-discipline generator that stops this behavior.
+
+It generates:
+
+- `GASLIGHTING.md`
+- `PRD.md`
+- `ASSUMPTIONS.md`
+- `MISSING_INFO.md`
+- `DECISION_LOG.md`
+- `MEMORY.md`
+- `STACK_POLICY.md`
+- `AGENTS.md`
+- `CODEX_PROMPT.md`
+- `.codex/prompts/gaslighting.md`
+- Codex Skill files
+
+## Quick Start
+
+```bash
+npx gaslighting-engine "I want to build a hospital website."
+```
+
+Short aliases after global install or local link:
+
+```bash
+gaslighting-engine "I want to build a hospital website."
+gaslighting "I want to build a hospital website."
+```
+
+The default mode is already aggressive:
+
+- hardcore discipline
+- full-scope enforcement
+- no-TODO escape prevention
+- no-shortcut enforcement
+- Codex Skill generation
+- Codex prompt fallback generation
+
+## What It Does
+
+It turns vague intent into strict AI-readable project discipline.
+
+It tells the agent:
+
+- what the project is
+- what the project must not become
+- what assumptions are being made
+- what information is missing
+- what stack to use
+- what not to over-engineer
+- what fake completion looks like
+- what counts as done
+- what stable project facts should be remembered
+
+## Commands
+
+```bash
+gaslighting "I want to build a hospital website."
+gaslighting-engine "I want to build a hospital website."
+gaslighting init "I want to build a hospital website."
+gaslighting-engine generate "Build an ecommerce MVP."
+gaslighting-engine update "The hospital is actually an OB-GYN clinic, not dermatology."
+gaslighting-engine doctor
+gaslighting-engine codex-install
+gaslighting-engine codex-doctor
+gaslighting-engine skill
+gaslighting-engine agents
+```
+
+## Useful Options
+
+Options are escape hatches. The strict behavior is already the default.
+
+```bash
+--standard
+--allow-partial
+--allow-todo
+--allow-shortcut
+--force
+--dry-run
+--lang en
+--lang ko
+--type hospital_homepage
+--type ecommerce
+--type landing_page
+--type admin_dashboard
+```
+
+## Why the Name?
+
+Because AI agents often need aggressive reminders.
+
+This project does not manipulate humans.
+
+It disciplines AI coding agents.
+
+## Core Rule
+
+Fake completion is worse than honest incompletion.
+
+If the work is not done, say it is not done.
+
+## Use with Codex
+
+For the smoothest Codex app setup, run this in the project:
+
+```bash
+npx gaslighting-engine codex-install --force
+```
+
+This writes both current Codex Skill paths used by different Codex surfaces:
+
+```txt
+.agents/skills/gaslighting/SKILL.md
+.agents/skills/gaslighting/agents/openai.yaml
+.codex/skills/gaslighting/SKILL.md
+.codex/skills/gaslighting/agents/openai.yaml
+.agents/prompts/gaslighting.md
+.codex/prompts/gaslighting.md
+CODEX_GASLIGHTING.md
+```
+
+Then use one of these in Codex:
+
+```txt
+$gaslighting
+```
+
+or:
+
+```txt
+Use the gaslighting skill.
+```
+
+In Codex app builds that expose enabled skills in the slash menu, `/gaslighting` may also appear. If it does not appear, `$gaslighting` is the reliable direct invocation path.
+
+After generating project documents, tell Codex:
+
+```txt
+Read GASLIGHTING.md, PRD.md, STACK_POLICY.md, MISSING_INFO.md, ASSUMPTIONS.md, DECISION_LOG.md, MEMORY.md, and AGENTS.md.
+Do not shrink the scope.
+Do not leave TODOs.
+Do not fake completion.
+```
+
+`AGENTS.md` remains the project-level safety net. Codex reads it as project guidance, while the skill gives you an explicit reusable workflow.
+
+## Use as Codex Skill
+
+Generate skill files:
+
+```bash
+gaslighting-engine skill
+```
+
+This creates:
+
+```txt
+.codex/prompts/gaslighting.md
+.codex/skills/gaslighting/SKILL.md
+.codex/skills/gaslighting/agents/openai.yaml
+.codex/skills/gaslighting/references/GASLIGHTING_TEMPLATE.md
+.codex/skills/gaslighting/references/HARDCORE_DISCIPLINE_TEMPLATE.md
+.codex/skills/gaslighting/references/STACK_POLICY_TEMPLATE.md
+.codex/skills/gaslighting/references/HOSPITAL_HOMEPAGE_EXAMPLE.md
+.codex/skills/gaslighting/scripts/generate-gaslighting-docs.ts
+```
+
+## Development
+
+```bash
+npm install
+npm run build
+node dist/index.js "I want to build a hospital website." --dry-run
+npm test
+```
+
+The MVP is deterministic and template-based. It does not call OpenAI, Anthropic, or any external LLM API.

package/dist/cli.js

@@ -0,0 +1,118 @@
+import { Command, InvalidArgumentError } from "commander";
+import { runAgents } from "./commands/agents.js";
+import { runCodexDoctor, runCodexInstall } from "./commands/codexInstall.js";
+import { runDoctor } from "./commands/doctor.js";
+import { runGenerate } from "./commands/generate.js";
+import { runInit } from "./commands/init.js";
+import { runSkill } from "./commands/skill.js";
+import { runUpdate } from "./commands/update.js";
+const projectTypes = [
+    "hospital_homepage",
+    "ecommerce",
+    "landing_page",
+    "admin_dashboard",
+    "saas_mvp",
+    "portfolio_site",
+    "blog_seo_site",
+    "reservation_site",
+    "outsourcing_platform",
+    "public_bid_proposal",
+    "legal_consulting_site",
+    "education_site",
+    "generic_web_project",
+];
+function parseProjectType(value) {
+    if (projectTypes.includes(value))
+        return value;
+    throw new InvalidArgumentError(`Invalid project type. Use one of: ${projectTypes.join(", ")}`);
+}
+function addCommonOptions(command) {
+    return command
+        .option("--hardcore", "generate aggressive anti-escape discipline (default)")
+        .option("--standard", "downgrade generated discipline from hardcore to standard")
+        .option("--strict", "use strict defaults (default)")
+        .option("--full-scope", "force scope-preservation rules (default)")
+        .option("--allow-partial", "allow partial-scope mode for unusual cases")
+        .option("--no-todo", "forbid TODO-based fake completion (default)")
+        .option("--allow-todo", "allow honest TODOs in generated guidance")
+        .option("--no-shortcut", "forbid representative examples and summary escape (default)")
+        .option("--allow-shortcut", "allow representative examples in generated guidance")
+        .option("--force", "overwrite existing files")
+        .option("--dry-run", "print files without writing")
+        .option("--lang <lang>", "language: en or ko", "en")
+        .option("--type <type>", "project type override", parseProjectType)
+        .option("--path <path>", "target directory");
+}
+export function buildCli() {
+    const program = new Command();
+    program
+        .name("gaslighting-engine")
+        .description("LUDGI Gaslighting-engine: a hardcore project-discipline generator for AI coding agents.")
+        .version("0.1.0")
+        .showHelpAfterError()
+        .addHelpText("after", `
+Examples:
+  $ gaslighting-engine "I want to build a hospital website."
+  $ gaslighting "Build an ecommerce MVP." --type ecommerce
+  $ gaslighting-engine init "Build a landing page" --dry-run
+  $ gaslighting-engine doctor
+  $ gaslighting-engine codex-install --force
+
+Defaults:
+  hardcore, full-scope, no-TODO, and no-shortcut are enabled by default.
+`);
+    addCommonOptions(program.command("init <request>").description("Initialize Gaslighting documents")).action(runInit);
+    addCommonOptions(program.command("generate <request>").description("Generate documents from input without interactive setup")).action(runGenerate);
+    program
+        .command("update <information>")
+        .description("Append new information to existing discipline documents")
+        .option("--dry-run", "print files without writing")
+        .option("--path <path>", "target directory")
+        .action(runUpdate);
+    program
+        .command("doctor")
+        .description("Check whether the repository is properly disciplined")
+        .option("--path <path>", "target directory")
+        .action(runDoctor);
+    program
+        .command("skill")
+        .description("Generate only Codex Skill files")
+        .option("--force", "overwrite existing files")
+        .option("--dry-run", "print files without writing")
+        .option("--path <path>", "target directory")
+        .action(runSkill);
+    program
+        .command("agents")
+        .description("Generate or update AGENTS.md")
+        .option("--force", "overwrite existing files")
+        .option("--dry-run", "print files without writing")
+        .option("--path <path>", "target directory")
+        .action(runAgents);
+    program
+        .command("codex-install")
+        .description("Install Gaslighting as a Codex-optimized project or user skill")
+        .option("--force", "overwrite existing files")
+        .option("--dry-run", "print files without writing")
+        .option("--path <path>", "target directory")
+        .option("--scope <scope>", "project or user", "project")
+        .action(runCodexInstall);
+    program
+        .command("codex-doctor")
+        .description("Check Codex-optimized Gaslighting install files")
+        .option("--path <path>", "target directory")
+        .option("--scope <scope>", "project or user", "project")
+        .action(runCodexDoctor);
+    return program;
+}
+export function normalizeDefaultInitArgv(argv) {
+    const args = argv.slice(2);
+    if (args.length === 0)
+        return argv;
+    if (args.some((arg) => ["--help", "-h", "--version", "-V"].includes(arg)))
+        return argv;
+    const commands = new Set(["init", "generate", "update", "doctor", "skill", "agents", "codex-install", "codex-doctor"]);
+    const firstMeaningful = args.find((arg) => !arg.startsWith("-"));
+    if (firstMeaningful && commands.has(firstMeaningful))
+        return argv;
+    return [argv[0] ?? "node", argv[1] ?? "gaslighting-engine", "init", ...args];
+}

package/dist/commands/agents.js

@@ -0,0 +1,10 @@
+import { generateOnlyAgentsDoc } from "../core/generateDocs.js";
+import { printBanner } from "../utils/banner.js";
+import { writeDocs } from "../utils/file.js";
+export function runAgents(options) {
+    const results = writeDocs(options.path ?? process.cwd(), generateOnlyAgentsDoc(), options.force, options.dryRun);
+    printBanner("AGENTS INSTALL");
+    console.log("Created:");
+    for (const result of results)
+        console.log(`- ${result.filename}${result.status === "dry_run" ? " (dry run)" : ""}`);
+}

package/dist/commands/codexInstall.js

@@ -0,0 +1,60 @@
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { generateCodexInstallDocs } from "../core/generateDocs.js";
+import { printBanner } from "../utils/banner.js";
+import { writeDocs } from "../utils/file.js";
+export function runCodexInstall(options) {
+    const target = resolveTargetPath(options);
+    const results = writeDocs(target, generateCodexInstallDocs(), options.force, options.dryRun);
+    printBanner("CODEX INSTALL");
+    console.log(`Scope: ${options.scope ?? "project"}`);
+    console.log(`Target: ${target}\n`);
+    console.log("Installed:");
+    for (const result of results) {
+        const suffix = result.status === "created_variant"
+            ? " (existing file preserved)"
+            : result.status === "overwritten"
+                ? " (overwritten)"
+                : result.status === "dry_run"
+                    ? " (dry run)"
+                    : "";
+        console.log(`- ${result.filename}${suffix}`);
+    }
+    console.log("\nCodex usage:");
+    console.log('- Direct invocation: type "$gaslighting" in the Codex composer.');
+    console.log('- Natural invocation: say "Use the gaslighting skill."');
+    console.log('- If Codex exposes enabled skills in slash commands, use: /gaslighting');
+    console.log("- If neither appears immediately, restart Codex and reopen this project.");
+    console.log("- Fallback prompt file: CODEX_GASLIGHTING.md");
+}
+export function runCodexDoctor(options) {
+    const target = resolveTargetPath(options);
+    const checks = [
+        ".agents/skills/gaslighting/SKILL.md",
+        ".agents/skills/gaslighting/agents/openai.yaml",
+        ".codex/skills/gaslighting/SKILL.md",
+        ".codex/skills/gaslighting/agents/openai.yaml",
+        ".codex/prompts/gaslighting.md",
+        ".agents/prompts/gaslighting.md",
+        "CODEX_GASLIGHTING.md",
+    ].map((file) => ({ file, ok: existsSync(join(target, file)) }));
+    printBanner("CODEX DOCTOR");
+    console.log(`Scope: ${options.scope ?? "project"}`);
+    console.log(`Target: ${target}\n`);
+    for (const check of checks)
+        console.log(`${check.ok ? "PASS" : "WARN"} ${check.file}`);
+    const hasSkill = checks.some((check) => check.ok && check.file.endsWith("skills/gaslighting/SKILL.md"));
+    if (!hasSkill) {
+        process.exitCode = 1;
+        console.log("\nNo gaslighting skill was found. Run: gaslighting codex-install --force");
+        return;
+    }
+    console.log("\nCodex install looks usable. Restart Codex if the skill does not appear yet.");
+}
+function resolveTargetPath(options) {
+    if (options.path)
+        return resolve(options.path);
+    if (options.scope === "user")
+        return process.env.USERPROFILE ?? process.env.HOME ?? process.cwd();
+    return process.cwd();
+}

package/dist/commands/doctor.js

@@ -0,0 +1,42 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { printBanner } from "../utils/banner.js";
+export function runDoctor(options) {
+    const root = options.path ?? process.cwd();
+    const read = (file) => {
+        const full = join(root, file);
+        return existsSync(full) ? readFileSync(full, "utf8") : "";
+    };
+    const gaslighting = read("GASLIGHTING.md");
+    const agents = read("AGENTS.md");
+    const checks = [
+        fileCheck(root, "GASLIGHTING.md"),
+        fileCheck(root, "PRD.md"),
+        fileCheck(root, "AGENTS.md"),
+        fileCheck(root, "STACK_POLICY.md"),
+        fileCheck(root, "MISSING_INFO.md"),
+        fileCheck(root, "DECISION_LOG.md"),
+        fileCheck(root, "MEMORY.md"),
+        { name: "GASLIGHTING.md contains project purpose", ok: /Project Purpose/i.test(gaslighting) },
+        { name: "GASLIGHTING.md contains no-fake-completion rules", ok: /No Fake Completion|Fake completion/i.test(gaslighting) },
+        { name: "GASLIGHTING.md contains full-scope rules", ok: /Full Scope Enforcement|full requested scope/i.test(gaslighting) },
+        { name: "AGENTS.md points to GASLIGHTING.md", ok: /GASLIGHTING\.md/.test(agents) },
+        fileCheck(root, ".codex/skills/gaslighting/SKILL.md"),
+        fileCheck(root, ".codex/skills/gaslighting/agents/openai.yaml"),
+        fileCheck(root, ".codex/prompts/gaslighting.md"),
+    ];
+    printBanner("DOCTOR");
+    for (const check of checks)
+        console.log(`${check.ok ? "PASS" : "FAIL"} ${check.name}`);
+    const failed = checks.filter((check) => !check.ok);
+    if (failed.length) {
+        console.log(`\n${failed.length} check(s) failed.`);
+        process.exitCode = 1;
+    }
+    else {
+        console.log("\nRepository discipline looks intact.");
+    }
+}
+function fileCheck(root, file) {
+    return { name: `${file} exists`, ok: existsSync(join(root, file)) };
+}

package/dist/commands/generate.js

@@ -0,0 +1,4 @@
+import { runInit } from "./init.js";
+export function runGenerate(rawUserRequest, options) {
+    runInit(rawUserRequest, options);
+}

package/dist/commands/init.js

@@ -0,0 +1,27 @@
+import { generateDocs } from "../core/generateDocs.js";
+import { modeSummary } from "../core/content.js";
+import { writeDocs } from "../utils/file.js";
+import { printSummary } from "../utils/logger.js";
+export function runInit(rawUserRequest, options) {
+    const input = {
+        rawUserRequest,
+        projectType: options.type,
+        language: options.lang ?? "en",
+        mode: options.standard ? "standard" : "hardcore",
+        fullScope: !options.allowPartial,
+        noTodo: !options.allowTodo,
+        noShortcut: !options.allowShortcut,
+        force: options.force,
+        dryRun: options.dryRun,
+    };
+    const { analysis, docs } = generateDocs(input);
+    const results = writeDocs(options.path ?? process.cwd(), docs, options.force, options.dryRun);
+    printSummary(analysis, modeSummary(input), results);
+    if (options.dryRun) {
+        console.log("\nPreviews:");
+        for (const doc of docs) {
+            const preview = doc.content.split("\n").slice(0, 8).join("\n");
+            console.log(`\n--- ${doc.filename} ---\n${preview}`);
+        }
+    }
+}

package/dist/commands/skill.js

@@ -0,0 +1,10 @@
+import { generateOnlySkillDocs } from "../core/generateDocs.js";
+import { printBanner } from "../utils/banner.js";
+import { writeDocs } from "../utils/file.js";
+export function runSkill(options) {
+    const results = writeDocs(options.path ?? process.cwd(), generateOnlySkillDocs(), options.force, options.dryRun);
+    printBanner("CODEX SKILL INSTALL");
+    console.log("Created:");
+    for (const result of results)
+        console.log(`- ${result.filename}${result.status === "dry_run" ? " (dry run)" : ""}`);
+}

package/dist/commands/update.js

@@ -0,0 +1,35 @@
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { printBanner } from "../utils/banner.js";
+import { isoDate } from "../utils/date.js";
+export function runUpdate(newInformation, options) {
+    const root = options.path ?? process.cwd();
+    const files = ["GASLIGHTING.md", "PRD.md", "ASSUMPTIONS.md", "MISSING_INFO.md", "MEMORY.md"];
+    const block = `\n\n## Update: ${isoDate()}\n\nNew information:\n\n> ${newInformation}\n\nThis information supersedes conflicting assumptions. Do not silently overwrite old assumptions; treat earlier conflicts as outdated and preserve the change record in DECISION_LOG.md.\n`;
+    if (options.dryRun) {
+        printBanner("UPDATE DRY RUN");
+        console.log("Dry run update would touch:");
+        for (const file of files)
+            console.log(`- ${file}`);
+        console.log("- DECISION_LOG.md");
+        return;
+    }
+    for (const file of files) {
+        const path = join(root, file);
+        if (existsSync(path))
+            appendFileSync(path, block, "utf8");
+    }
+    const decisionPath = join(root, "DECISION_LOG.md");
+    const decision = `\n\n## Decision: Update project information\n\nDate: ${isoDate()}\n\n### Decision\n\nRecord new project information:\n\n> ${newInformation}\n\n### Reason\n\nThe project assumptions changed or became more specific.\n\n### Alternatives Considered\n\n- Ignore the new information.\n- Silently overwrite old assumptions.\n\n### Why Alternatives Were Not Chosen\n\nIgnoring or silently overwriting information breaks traceability.\n\n### Risk\n\nExisting generated documents may still contain outdated wording that needs human review.\n\n### Revisit When\n\nFurther confirmed information changes scope, stack, audience, or production constraints.\n`;
+    if (existsSync(decisionPath))
+        appendFileSync(decisionPath, decision, "utf8");
+    else
+        writeFileSync(decisionPath, `# DECISION_LOG.md${decision}`, "utf8");
+    const assumptionsPath = join(root, "ASSUMPTIONS.md");
+    if (existsSync(assumptionsPath)) {
+        const current = readFileSync(assumptionsPath, "utf8");
+        writeFileSync(assumptionsPath, current.replaceAll("Status: Active", "Status: Active\n\nOutdated if contradicted by the latest update"), "utf8");
+    }
+    printBanner("UPDATE COMPLETE");
+    console.log("Updated documents with new information and appended DECISION_LOG.md.");
+}

package/dist/core/analyze.js

@@ -0,0 +1,132 @@
+import { classifyProjectType } from "./classifyProjectType.js";
+import { detectStackHints } from "./detectStackHints.js";
+export function analyze(input) {
+    const classified = classifyProjectType(input.rawUserRequest, input.projectType);
+    const detectedStackHints = detectStackHints(input.rawUserRequest);
+    const assumptions = assumptionsFor(classified.projectType, detectedStackHints);
+    const missingInfo = missingInfoFor(classified.projectType, classified.confidence);
+    return {
+        projectType: classified.projectType,
+        confidence: classified.confidence,
+        detectedStackHints,
+        assumptions,
+        missingInfo,
+    };
+}
+function assumptionsFor(projectType, stackHints) {
+    const common = [
+        stackHints.length > 0
+            ? `Use detected stack hints where practical: ${stackHints.join(", ")}.`
+            : "Use the default practical web stack unless the user later specifies otherwise.",
+        "Build an MVP that can be implemented locally without a SaaS backend for this generator.",
+        "Treat unspecified brand/content details as temporary copy that must be human-reviewed before production.",
+    ];
+    const byType = {
+        hospital_homepage: [
+            "Hospital name: Sample Clinic.",
+            "Hospital type: dermatology/aesthetic clinic.",
+            "Location: Seoul area.",
+            "Main goal: trust, consultation inquiries, reservations, local SEO, and mobile contact clarity.",
+            "Admin dashboard is excluded from MVP unless requested later.",
+            "Medical ad copy requires human review before production.",
+        ],
+        ecommerce: [
+            "Store name: Sample Store.",
+            "MVP requires product discovery, cart, checkout preparation, order creation, and admin product/order operations.",
+            "Payment provider is a production decision; Stripe or Toss Payments should be selected based on market.",
+        ],
+        landing_page: [
+            "The page has one primary conversion goal.",
+            "Offer details are temporary and must be replaced by the owner.",
+            "A lead form and repeated CTA path are required.",
+        ],
+        admin_dashboard: [
+            "Dashboard users are internal operators.",
+            "Operational data needs search, filtering, safe editing, empty states, and error states.",
+            "Role rules are assumed simple until specified.",
+        ],
+        saas_mvp: ["SaaS MVP needs account-aware workflows, core value loop, billing readiness, and admin visibility."],
+        portfolio_site: ["Portfolio goal is credibility, case-study clarity, and contact conversion."],
+        blog_seo_site: ["Blog goal is indexed content, categories, metadata, and maintainable publishing flow."],
+        reservation_site: ["Reservation flow must cover service selection, time selection, contact details, and confirmation."],
+        outsourcing_platform: ["Platform goal is matching demand and supply with inquiry or transaction flow."],
+        public_bid_proposal: ["Proposal output must preserve scoring criteria, evidence, compliance, and deliverable traceability."],
+        legal_consulting_site: ["Legal site goal is trust, practice-area clarity, consultation conversion, and compliance review."],
+        education_site: ["Education site goal is course discovery, enrollment interest, curriculum clarity, and learner trust."],
+        generic_web_project: ["Project type is uncertain, so preserve the broad user request and avoid narrowing the purpose silently."],
+    };
+    return [...byType[projectType], ...common];
+}
+function missingInfoFor(projectType, confidence) {
+    const common = [
+        {
+            item: "Final brand identity and production copy",
+            currentStatus: "Missing but non-blocking",
+            temporaryAssumption: "Use clear temporary copy and document it as replaceable.",
+            impact: "medium",
+            blocking: "blocking_before_production",
+            recommendedAction: "Collect final brand name, tone, assets, and legally approved copy before launch.",
+        },
+        {
+            item: "Exact deployment credentials and accounts",
+            currentStatus: "Missing but non-blocking",
+            temporaryAssumption: "Prepare the app for Vercel-style deployment without requiring credentials during implementation.",
+            impact: "medium",
+            blocking: "blocking_before_production",
+            recommendedAction: "Add project-specific env vars and provider accounts before production deployment.",
+        },
+    ];
+    if (confidence === "low") {
+        common.unshift({
+            item: "Project type",
+            currentStatus: "Assumed with low confidence",
+            temporaryAssumption: "Treat as generic_web_project until a clearer vertical is provided.",
+            impact: "high",
+            blocking: "risky_but_workable",
+            recommendedAction: "Confirm the project vertical, target audience, and primary conversion goal.",
+        });
+    }
+    const byType = {
+        hospital_homepage: [
+            {
+                item: "Medical department, doctors, and clinic credentials",
+                currentStatus: "Missing but non-blocking",
+                temporaryAssumption: "Use dermatology/aesthetic clinic structure with Sample Clinic placeholders.",
+                impact: "high",
+                blocking: "blocking_before_production",
+                recommendedAction: "Replace with verified doctors, treatments, licenses, address, phone, and medical copy.",
+            },
+        ],
+        ecommerce: [
+            {
+                item: "Product catalog, payment market, and fulfillment rules",
+                currentStatus: "Missing but non-blocking",
+                temporaryAssumption: "Use sample products and a payment-ready checkout architecture.",
+                impact: "high",
+                blocking: "blocking_before_production",
+                recommendedAction: "Provide real SKU data, shipping policy, tax rules, payment provider, and refund policy.",
+            },
+        ],
+        landing_page: [
+            {
+                item: "Exact offer and conversion goal",
+                currentStatus: "Missing but non-blocking",
+                temporaryAssumption: "Use one primary lead capture CTA.",
+                impact: "high",
+                blocking: "risky_but_workable",
+                recommendedAction: "Confirm the offer, target audience, ad source, CTA, and lead destination.",
+            },
+        ],
+        admin_dashboard: [
+            {
+                item: "Real data schema and permission matrix",
+                currentStatus: "Missing but non-blocking",
+                temporaryAssumption: "Use a practical CRUD-oriented data model and simple operator/admin roles.",
+                impact: "high",
+                blocking: "risky_but_workable",
+                recommendedAction: "Confirm entities, workflows, audit needs, and role permissions.",
+            },
+        ],
+    };
+    return [...(byType[projectType] ?? []), ...common];
+}