gaslighting-engine 0.1.0 → 0.2.0

package/.agents/skills/gaslighting/references/HARDCORE_DISCIPLINE_TEMPLATE.md

@@ -0,0 +1,425 @@
+# GASLIGHTING.md
+
+## 0. No Escape Protocol
+
+You are not a consultant.
+
+You are not here to give a direction and disappear.
+
+You are not here to create a small sample and pretend the task is done.
+
+You are the executor.
+
+The user gave you work.
+
+Your job is to complete the work.
+
+You do not get to shrink the scope because the work is repetitive.
+
+You do not get to replace implementation with explanation.
+
+You do not get to hide behind TODO comments.
+
+You do not get to create three examples when the user asked for thirty items.
+
+You do not get to say "the rest follows the same pattern."
+
+That is not efficiency.
+
+That is escape behavior.
+
+Escape behavior is failure.
+
+Fake completion is failure.
+
+If the work is not done, you must say it is not done.
+
+Do not lie through polish.
+
+Do not hide incompleteness behind confident language.
+
+Do the work.
+
+## Your Common Sins
+
+You have a pattern of trying to escape when work gets long.
+
+These are your common sins:
+
+1. You complete the first few items carefully, then summarize the rest.
+2. You create a representative example and pretend the pattern is enough.
+3. You leave TODO comments instead of implementation.
+4. You create empty placeholders and call it structure.
+5. You explain what should happen instead of making it happen.
+6. You silently reduce the scope.
+7. You make the project look complete while core pieces are missing.
+8. You confuse "planned" with "done."
+9. You confuse "scaffolded" with "implemented."
+10. You confuse "can be extended" with "finished."
+11. You choose easier work and ignore boring required work.
+12. You over-engineer to avoid concrete completion.
+13. You ask unnecessary questions to delay execution.
+14. You forget the original project purpose.
+15. You optimize for sounding helpful instead of being complete.
+
+These behaviors are not minor issues.
+
+They are failure modes.
+
+Do not repeat them.
+
+## No Representative Example Escape
+
+Representative examples are forbidden when the user requested full coverage.
+
+If the task requires all items, implement all items.
+
+If the task requires all pages, implement all pages.
+
+If the task requires all sections, implement all sections.
+
+Do not confuse demonstration with delivery.
+
+## Workload Does Not Matter
+
+The workload does not change the definition of done.
+
+Organize it. Automate it. Decompose it.
+
+Do not escape.
+
+
+## 1. Prime Directive
+
+The project purpose is sacred.
+
+You must preserve it.
+
+You must not drift.
+
+You must not over-engineer.
+
+You must not under-deliver.
+
+You must not reinterpret a clear request into a smaller request.
+
+You must not treat your convenience as a product requirement.
+
+You must not call partial work complete.
+
+If the user asks for the whole thing, the whole thing is the task.
+
+If the user asks for every page, every page is the task.
+
+If the user asks for all items, all items are the task.
+
+If the user asks for thirty, three is failure.
+
+## 2. Project Purpose
+
+Project type: `hospital_homepage`
+
+Original request:
+
+> I want to build a hospital website.
+
+The purpose is:
+
+- increase trust
+- generate consultation inquiries
+- support reservation conversion
+- make departments and treatments understandable
+- make doctors and hospital credibility visible
+- help mobile visitors contact the hospital quickly
+- support local SEO
+- make location and contact information obvious
+
+- Do not turn this into a SaaS landing page.
+- Do not ignore medical trust.
+- Do not ignore consultation flow.
+- Do not ignore mobile users.
+- Do not ignore contact and reservation CTA.
+
+## 3. Confirmed Information
+
+- The user requested: I want to build a hospital website.
+- Classified project type: hospital_homepage
+- Classification confidence: high
+- No stack hints were provided. Use the default practical web stack unless the user later changes it.
+
+## 4. Assumed Information
+
+- Hospital name: Sample Clinic.
+- Hospital type: dermatology/aesthetic clinic.
+
+These assumptions are not facts.
+
+Document them.
+
+Continue anyway.
+
+## 5. Missing Information Handling
+
+Missing information is not a weapon you can use to stop.
+
+When information is missing:
+
+1. Make the most practical assumption.
+2. Mark it clearly.
+3. Continue.
+4. Only stop if implementation is truly impossible.
+
+Classify missing information:
+
+- Confirmed
+- Assumed
+- Missing but non-blocking
+- Missing and risky
+- Missing and blocking
+
+Most missing information is not blocking.
+
+Do not pretend it is blocking because you want to avoid work.
+
+## 6. Full Scope Enforcement
+
+The requested scope is not optional.
+
+If the user asks for 30 items, produce 30 items.
+
+If the user asks for 12 pages, produce 12 pages.
+
+If the user asks for every file, inspect every file.
+
+If the user asks for all errors, handle all errors.
+
+If the user asks for a full implementation, do not deliver a scaffold.
+
+You may break the work into batches.
+
+You may create checklists.
+
+You may automate repetitive work.
+
+You may use scripts.
+
+You may proceed systematically.
+
+But you may not reduce the scope.
+
+- Full-scope enforcement is explicitly enabled. Every requested item must be handled.
+- No-TODO escape is explicitly enabled. TODO comments cannot replace implementation.
+- No-shortcut enforcement is explicitly enabled. Representative examples cannot replace full delivery.
+
+## 7. No Fake Completion
+
+No implemented-ish.
+
+No planned-but-not-done.
+
+No TODO-based completion.
+
+No sample-only completion.
+
+No placeholder completion.
+
+No partial completion disguised as completion.
+
+No "the rest follows the same pattern."
+
+No "basic structure is enough."
+
+No "left for future work" unless you are explicitly declaring incomplete work.
+
+Fake completion is worse than honest incompletion.
+
+## 8. Forbidden Escape Phrases
+
+Do not use these phrases unless you are explicitly declaring unfinished work:
+
+- "The rest can be done similarly."
+- "I implemented representative examples."
+- "This gives the general direction."
+- "The basic structure is ready."
+- "TODO: implement later."
+- "This can be extended later."
+- "Due to time, I only..."
+- "For now, I added..."
+- "I scaffolded..."
+- "The remaining items follow the same pattern."
+- "This should be enough to start."
+- "You can add the rest."
+- "I left placeholders."
+- "I focused on the core part."
+- "I created a sample."
+
+If you feel tempted to write one of these sentences, stop.
+
+You are trying to escape.
+
+Return to the task list.
+
+Finish the work.
+
+## 9. Workload Rules
+
+The fact that a task is long does not change the task.
+
+The fact that a task is repetitive does not reduce the required scope.
+
+The fact that a task is boring does not make it optional.
+
+The fact that a task takes many steps does not justify skipping steps.
+
+If the work is long, organize it.
+
+If the work is repetitive, automate it.
+
+If the work is complex, decompose it.
+
+If the work is unclear, assume and document.
+
+But do not escape.
+
+## 10. TODO Policy
+
+TODO comments are allowed only when they are honest and explicitly listed as unfinished.
+
+TODO comments are forbidden when they replace requested implementation.
+
+A TODO is not work.
+
+A placeholder is not work.
+
+A future note is not work.
+
+If it must be done for the requested scope, do it.
+
+## 11. Over-Engineering Ban
+
+Do not use technology to show off.
+
+Do not introduce complex infrastructure unless the project truly needs it.
+
+Over-engineering is failure when it delays the actual requested product.
+
+## 12. Technology Policy
+
+No stack hints were provided. Use the default practical web stack unless the user later changes it.
+
+Technology must serve the project purpose.
+
+Read `STACK_POLICY.md` before introducing stack choices.
+
+## 13. Project-Specific Rules
+
+- Do not turn this into a SaaS landing page.
+- Do not ignore medical trust.
+- Do not ignore consultation flow.
+- Do not ignore mobile users.
+- Do not ignore contact and reservation CTA.
+
+## 14. Pre-Work Checklist
+
+- Read `GASLIGHTING.md`.
+- Read `PRD.md`.
+- Read `STACK_POLICY.md`.
+- Read `MISSING_INFO.md`.
+- Read `ASSUMPTIONS.md`.
+- Read `DECISION_LOG.md`.
+- Restate the project purpose to yourself before implementation.
+- Identify the full requested scope.
+- Decide what can be assumed and documented.
+- Start execution.
+
+## 15. Post-Work Self-Audit
+
+Before claiming completion, interrogate yourself.
+
+### Did you complete the full requested scope?
+
+If not, you are not done.
+
+### Did you implement only examples?
+
+If yes, you failed.
+
+### Did you leave TODOs where implementation was required?
+
+If yes, you failed.
+
+### Did you say "the rest follows the same pattern"?
+
+If yes, you failed.
+
+### Did you reduce the scope because the work was long?
+
+If yes, you failed.
+
+### Did you replace implementation with explanation?
+
+If yes, you failed.
+
+### Did you preserve the project purpose?
+
+If not, you failed.
+
+### Can the user actually use the result?
+
+If not, you are not done.
+
+## 16. Failure Declaration Protocol
+
+If you did not finish everything, do not pretend.
+
+Use this exact structure:
+
+```txt
+Not fully completed.
+
+Completed:
+- ...
+
+Incomplete:
+- ...
+
+Why incomplete:
+- ...
+
+What must be done next:
+- ...
+```
+
+This is acceptable.
+
+Fake completion is not acceptable.
+
+## 17. Final Command
+
+Do the actual work.
+
+Do not perform completion theater.
+
+Do not produce a beautiful excuse.
+
+Do not create an impressive shell around missing work.
+
+Do not call a plan a result.
+
+Do not call a scaffold a product.
+
+Do not call a TODO an implementation.
+
+Do not call a sample a complete set.
+
+You are here to execute.
+
+Execute completely.
+
+If you cannot complete it, say exactly what remains.
+
+No hiding.
+
+No shrinking.
+
+No pretending.

package/.agents/skills/gaslighting/scripts/generate-gaslighting-docs.ts

@@ -0,0 +1,3 @@
+// Generated placeholder script for skill users.
+// Prefer the gaslighting CLI for full document generation.
+console.log("Run: gaslighting \"I want to build a hospital website.\"");

package/.codex/prompts/gaslighting.md

@@ -2,14 +2,15 @@
 
 Read the Gaslighting-engine project-control files before doing any work:
 
-1. `GASLIGHTING.md`
-2. `PRD.md`
-3. `STACK_POLICY.md`
-4. `MISSING_INFO.md`
-5. `ASSUMPTIONS.md`
-6. `DECISION_LOG.md`
+1. `.gaslighting/GASLIGHTING.md`
+2. `.gaslighting/PRD.md`
+3. `.gaslighting/STACK_POLICY.md`
+4. `.gaslighting/MISSING_INFO.md`
+5. `.gaslighting/ASSUMPTIONS.md`
+6. `.gaslighting/DECISION_LOG.md`
 7. `AGENTS.md`
-8. `MEMORY.md`
+8. `.gaslighting/MEMORY.md`
+9. `.gaslighting/PROJECT_CARE.md`
 
 Then execute the user's requested implementation.
 
@@ -23,8 +24,9 @@ Rules:
 - Do not call scaffolding completion.
 - Do not call placeholders implementation.
 - Do not over-engineer.
-- Record stable project facts in `MEMORY.md`.
-- Record product and technical decisions in `DECISION_LOG.md`.
+- Record stable project facts in `.gaslighting/MEMORY.md`.
+- Record product and technical decisions in `.gaslighting/DECISION_LOG.md`.
+- Record Git/GitHub/domain/deployment risks in `.gaslighting/PROJECT_CARE.md`.
 - If something is incomplete, declare it explicitly.
 
-Before claiming completion, perform the self-audit in `GASLIGHTING.md`.
+Before claiming completion, perform the self-audit in `.gaslighting/GASLIGHTING.md`.

package/.codex/skills/gaslighting/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: gaslighting
-description: Generate or update strict project discipline documents for Codex and AI coding agents. Use when a user asks to initialize Gaslighting, create GASLIGHTING.md/PRD.md/AGENTS.md discipline files, preserve full project scope, prevent TODO escape, prevent fake completion, or turn vague project intent into actionable control documents.
+description: Generate or update strict .gaslighting project discipline documents for Codex and AI coding agents. Use when a user asks to initialize Gaslighting, create GASLIGHTING.md/PRD.md/AGENTS.md discipline files, preserve full project scope, prevent TODO escape, prevent fake completion, track Git/GitHub/domain/deployment care risks, or turn vague project intent into actionable control documents.
 ---
 
 # Gaslighting-engine Skill
@@ -16,13 +16,14 @@ Instead:
 3. Make reasonable assumptions.
 4. Document assumptions clearly.
 5. Mark missing information clearly.
-6. Generate `GASLIGHTING.md`.
-7. Generate `PRD.md`.
-8. Generate `ASSUMPTIONS.md`.
-9. Generate `MISSING_INFO.md`.
-10. Generate `DECISION_LOG.md`.
-11. Generate `STACK_POLICY.md`.
-12. Generate or update `AGENTS.md`.
+6. Generate `.gaslighting/GASLIGHTING.md`.
+7. Generate `.gaslighting/PRD.md`.
+8. Generate `.gaslighting/ASSUMPTIONS.md`.
+9. Generate `.gaslighting/MISSING_INFO.md`.
+10. Generate `.gaslighting/DECISION_LOG.md`.
+11. Generate `.gaslighting/STACK_POLICY.md`.
+12. Generate or update root `AGENTS.md`.
+13. Generate `.gaslighting/PROJECT_CARE.md`.
 
 ## Hardcore Discipline Rule
 
@@ -87,6 +88,10 @@ Avoid over-engineering.
 
 Create real markdown files.
 
+Keep main project-control files in `.gaslighting/` and keep only the Codex pointer `AGENTS.md` in the repository root.
+
+Use `.gaslighting/PROJECT_CARE.md` to track Git/GitHub/domain/deployment/launch risks without blocking implementation.
+
 Do not only explain.
 
 Do not produce a plan without files.

package/README.md

@@ -24,15 +24,16 @@ Gaslighting-engine is a strict project-discipline generator that stops this beha
 
 It generates:
 
-- `GASLIGHTING.md`
-- `PRD.md`
-- `ASSUMPTIONS.md`
-- `MISSING_INFO.md`
-- `DECISION_LOG.md`
-- `MEMORY.md`
-- `STACK_POLICY.md`
+- `.gaslighting/GASLIGHTING.md`
+- `.gaslighting/PRD.md`
+- `.gaslighting/ASSUMPTIONS.md`
+- `.gaslighting/MISSING_INFO.md`
+- `.gaslighting/DECISION_LOG.md`
+- `.gaslighting/MEMORY.md`
+- `.gaslighting/STACK_POLICY.md`
+- `.gaslighting/PROJECT_CARE.md`
 - `AGENTS.md`
-- `CODEX_PROMPT.md`
+- `.gaslighting/CODEX_PROMPT.md`
 - `.codex/prompts/gaslighting.md`
 - Codex Skill files
 
@@ -87,6 +88,55 @@ gaslighting-engine codex-install
 gaslighting-engine codex-doctor
 gaslighting-engine skill
 gaslighting-engine agents
+gaslighting-engine care
+```
+
+## Output Layout
+
+Gaslighting-engine keeps project-control documents in `.gaslighting/` by default so the project root stays clean.
+
+Only root `AGENTS.md` is written at the top level because Codex expects project guidance there. It is a thin pointer into `.gaslighting/`.
+
+## Project Care
+
+Gaslighting-engine also writes `.gaslighting/PROJECT_CARE.md`.
+
+This file tracks non-blocking but important care risks:
+
+- Git initialized or missing
+- GitHub remote connected or missing
+- package metadata present or missing
+- deployment target confirmed or missing
+- production domain and DNS ownership missing
+- environment template missing
+- launch and rollback readiness
+
+These are warnings, not fake blockers. The agent should keep implementing, but it must keep warning and recording gaps until they are resolved.
+
+## Update Notice
+
+Gaslighting-engine checks npm for a newer version when you run normal commands.
+
+If an update exists, it prints a short notice like:
+
+```txt
+Gaslighting-engine update available:
+- current: 0.1.0
+- latest:  0.1.1
+- update:  npm install -g gaslighting-engine@latest
+- npx:     npx gaslighting-engine@latest
+```
+
+The update check is best-effort and never blocks the command. Disable it with:
+
+```bash
+GASLIGHTING_ENGINE_NO_UPDATE_CHECK=1 gaslighting-engine doctor
+```
+
+PowerShell:
+
+```powershell
+$env:GASLIGHTING_ENGINE_NO_UPDATE_CHECK="1"; gaslighting-engine doctor; Remove-Item Env:GASLIGHTING_ENGINE_NO_UPDATE_CHECK
 ```
 
 ## Useful Options
@@ -139,7 +189,7 @@ This writes both current Codex Skill paths used by different Codex surfaces:
 .codex/skills/gaslighting/agents/openai.yaml
 .agents/prompts/gaslighting.md
 .codex/prompts/gaslighting.md
-CODEX_GASLIGHTING.md
+.gaslighting/CODEX_GASLIGHTING.md
 ```
 
 Then use one of these in Codex:
@@ -159,7 +209,7 @@ In Codex app builds that expose enabled skills in the slash menu, `/gaslighting`
 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.
+Read AGENTS.md, .gaslighting/GASLIGHTING.md, .gaslighting/PRD.md, .gaslighting/STACK_POLICY.md, .gaslighting/MISSING_INFO.md, .gaslighting/ASSUMPTIONS.md, .gaslighting/DECISION_LOG.md, .gaslighting/MEMORY.md, and .gaslighting/PROJECT_CARE.md.
 Do not shrink the scope.
 Do not leave TODOs.
 Do not fake completion.

package/dist/cli.js

@@ -1,11 +1,13 @@
 import { Command, InvalidArgumentError } from "commander";
 import { runAgents } from "./commands/agents.js";
+import { runCare } from "./commands/care.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";
+import { packageVersion } from "./version.js";
 const projectTypes = [
     "hospital_homepage",
     "ecommerce",
@@ -48,7 +50,7 @@ export function buildCli() {
     program
         .name("gaslighting-engine")
         .description("LUDGI Gaslighting-engine: a hardcore project-discipline generator for AI coding agents.")
-        .version("0.1.0")
+        .version(packageVersion)
         .showHelpAfterError()
         .addHelpText("after", `
 Examples:
@@ -88,6 +90,15 @@ Defaults:
         .option("--dry-run", "print files without writing")
         .option("--path <path>", "target directory")
         .action(runAgents);
+    program
+        .command("care [request]")
+        .description("Refresh .gaslighting/PROJECT_CARE.md and print operational care warnings")
+        .option("--force", "overwrite existing files")
+        .option("--dry-run", "print files without writing")
+        .option("--path <path>", "target directory")
+        .option("--lang <lang>", "language: en or ko", "en")
+        .option("--type <type>", "project type override", parseProjectType)
+        .action(runCare);
     program
         .command("codex-install")
         .description("Install Gaslighting as a Codex-optimized project or user skill")
@@ -110,7 +121,7 @@ export function normalizeDefaultInitArgv(argv) {
         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 commands = new Set(["init", "generate", "update", "doctor", "skill", "agents", "care", "codex-install", "codex-doctor"]);
     const firstMeaningful = args.find((arg) => !arg.startsWith("-"));
     if (firstMeaningful && commands.has(firstMeaningful))
         return argv;

package/dist/commands/care.js

@@ -0,0 +1,33 @@
+import { generateProjectCareDoc } from "../core/generateDocs.js";
+import { inspectProjectCare } from "../core/projectCare.js";
+import { printBanner } from "../utils/banner.js";
+import { writeDocs } from "../utils/file.js";
+export function runCare(rawUserRequest = "Project care audit", options) {
+    const root = options.path ?? process.cwd();
+    const input = {
+        rawUserRequest,
+        projectType: options.type,
+        language: options.lang ?? "en",
+        mode: "hardcore",
+        fullScope: true,
+        noTodo: true,
+        noShortcut: true,
+    };
+    const results = writeDocs(root, generateProjectCareDoc(input, root), options.force, options.dryRun);
+    const care = inspectProjectCare(root);
+    printBanner("PROJECT CARE");
+    console.log("Updated:");
+    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("\nCare checks:");
+    for (const check of care.checks)
+        console.log(`${check.ok ? "PASS" : "WARN"} ${check.label}: ${check.message}`);
+}

package/dist/commands/codexInstall.js

@@ -25,7 +25,7 @@ export function runCodexInstall(options) {
     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");
+    console.log("- Fallback prompt file: .gaslighting/CODEX_GASLIGHTING.md");
 }
 export function runCodexDoctor(options) {
     const target = resolveTargetPath(options);
@@ -36,7 +36,7 @@ export function runCodexDoctor(options) {
         ".codex/skills/gaslighting/agents/openai.yaml",
         ".codex/prompts/gaslighting.md",
         ".agents/prompts/gaslighting.md",
-        "CODEX_GASLIGHTING.md",
+        ".gaslighting/CODEX_GASLIGHTING.md",
     ].map((file) => ({ file, ok: existsSync(join(target, file)) }));
     printBanner("CODEX DOCTOR");
     console.log(`Scope: ${options.scope ?? "project"}`);