gaslighting-engine 0.3.0 → 0.3.1

package/README.md

@@ -122,6 +122,20 @@ It shows:
 - Codex runtime args
 - Start Codex action
 
+By default, `Start Codex` closes the local cockpit server and continues Codex in the same terminal that launched Mission Control. This keeps Cursor, Warp, Windows Terminal, or any other terminal flow intact.
+
+If you explicitly want a separate terminal, add:
+
+```bash
+npx gaslighting-engine@latest start "I want to build a hospital website." --new-terminal
+```
+
+To customize Codex flags, use:
+
+```bash
+npx gaslighting-engine@latest start "I want to build a hospital website." --codex-args="--search --dangerously-bypass-approvals-and-sandbox"
+```
+
 Open it for an existing project:
 
 ```bash

package/dist/cli.js

@@ -117,6 +117,7 @@ Defaults:
         .option("--lang <lang>", "language: en or ko", "en")
         .option("--type <type>", "project type override", parseProjectType)
         .option("--codex-args <args>", "Codex CLI args used by the Start Codex button")
+        .option("--new-terminal", "launch Codex in a separate terminal instead of handing off the current terminal")
         .action(runStart);
     program
         .command("cockpit [request]")
@@ -130,6 +131,7 @@ Defaults:
         .option("--lang <lang>", "language: en or ko", "en")
         .option("--type <type>", "project type override", parseProjectType)
         .option("--codex-args <args>", "Codex CLI args used by the Start Codex button")
+        .option("--new-terminal", "launch Codex in a separate terminal instead of handing off the current terminal")
         .action(runCockpit);
     program
         .command("run <request>")
@@ -140,6 +142,7 @@ Defaults:
         .option("--lang <lang>", "language: en or ko", "en")
         .option("--type <type>", "project type override", parseProjectType)
         .option("--codex-args <args>", "Codex CLI args")
+        .option("--new-terminal", "launch Codex in a separate terminal instead of handing off the current terminal")
         .action(runCodexRun);
     program
         .command("upgrade")

package/dist/commands/cockpit.js

@@ -4,7 +4,7 @@ import { createServer } from "node:http";
 import { join, resolve } from "node:path";
 import { platform } from "node:os";
 import { analyze } from "../core/analyze.js";
-import { getDefaultCodexArgs, launchCodex } from "../core/codexRuntime.js";
+import { buildCodexCommand, getDefaultCodexArgs, launchCodexInCurrentTerminal, launchCodexInNewTerminal } from "../core/codexRuntime.js";
 import { pageList, projectPurpose } from "../core/content.js";
 import { generateCodexInstallDocs, generateDocs, generateProjectCareDoc } from "../core/generateDocs.js";
 import { renderCockpitHtml } from "../core/cockpitHtml.js";
@@ -34,10 +34,14 @@ export function runCodexRun(rawUserRequest, options) {
     const input = makeInput(rawUserRequest, options);
     writeDocs(root, generateDocs(input, root).docs, options.force ?? true, false);
     writeDocs(root, generateCodexInstallDocs(), true, false);
-    const result = launchCodex({ root, request: rawUserRequest, codexArgs: options.codexArgs });
     printBanner("CODEX RUN");
-    console.log(result.message);
-    console.log(result.command);
+    console.log(options.newTerminal ? "Starting Codex in a new terminal." : "Handing this terminal over to Codex.");
+    console.log(buildCodexCommand({ root, request: rawUserRequest, codexArgs: options.codexArgs }));
+    const result = options.newTerminal
+        ? launchCodexInNewTerminal({ root, request: rawUserRequest, codexArgs: options.codexArgs })
+        : launchCodexInCurrentTerminal({ root, request: rawUserRequest, codexArgs: options.codexArgs });
+    if (!result.ok)
+        console.log(result.message);
 }
 async function openCockpit(rawUserRequest, options) {
     const root = resolve(options.path ?? process.cwd());
@@ -66,8 +70,19 @@ async function openCockpit(rawUserRequest, options) {
                 currentRequest = String(body.request || currentRequest);
                 currentInput = makeInput(currentRequest, options);
                 writeDocs(root, generateDocs(currentInput, root).docs, true, false);
-                const result = launchCodex({ root, request: currentRequest, codexArgs: options.codexArgs });
-                return sendJson(response, { ...result });
+                if (options.newTerminal) {
+                    const result = launchCodexInNewTerminal({ root, request: currentRequest, codexArgs: options.codexArgs });
+                    return sendJson(response, { ...result });
+                }
+                const commandPreview = launchMessageForCurrentTerminal(root, currentRequest, options);
+                sendJson(response, commandPreview);
+                setTimeout(() => {
+                    server.close(() => {
+                        console.log("\nMission Control is handing off to Codex in this terminal.\n");
+                        launchCodexInCurrentTerminal({ root, request: currentRequest, codexArgs: options.codexArgs });
+                    });
+                }, 250);
+                return;
             }
             if (request.method === "POST" && request.url === "/api/connect-github") {
                 const body = await readJson(request);
@@ -108,9 +123,17 @@ function buildState(root, request, input, options) {
         care: inspectProjectCare(root),
         docsPresent,
         codexArgs: options.codexArgs || getDefaultCodexArgs(),
+        launchMode: options.newTerminal ? "new_terminal" : "current_terminal",
         codexAvailable: isCommandAvailable("codex"),
     };
 }
+function launchMessageForCurrentTerminal(root, request, options) {
+    return {
+        ok: true,
+        command: buildCodexCommand({ root, request, codexArgs: options.codexArgs }),
+        message: "Mission Control will close and Codex will continue in the same terminal that launched it.",
+    };
+}
 function makeInput(rawUserRequest, options) {
     return {
         rawUserRequest,

package/dist/core/cockpitHtml.js

@@ -424,7 +424,7 @@ export function renderCockpitHtml() {
           <div class="action-card"><div><strong>Refresh Docs</strong><br /><span>Regenerate .gaslighting and root AGENTS.md from the current request.</span></div><button id="generateBtn">Generate</button></div>
           <div class="action-card"><div><strong>Connect GitHub</strong><br /><span>Initialize Git if needed and connect origin without blocking implementation.</span></div><button id="githubBtn">Connect</button></div>
           <div class="action-card"><div><strong>Doctor</strong><br /><span>Check discipline documents and operational care state.</span></div><button id="doctorBtn">Check</button></div>
-          <div class="action-card"><div><strong>Start Codex</strong><br /><span>Launch Codex with the Gaslighting contract already loaded.</span></div><button class="primary" id="startCardBtn">Start</button></div>
+          <div class="action-card"><div><strong>Start Codex</strong><br /><span>Close the cockpit server and continue Codex in this same terminal.</span></div><button class="primary" id="startCardBtn">Start</button></div>
         </div>
       </footer>
     </main>
@@ -436,6 +436,7 @@ export function renderCockpitHtml() {
       </div>
       <div class="side-panel">
         <h3>Runtime</h3>
+        <div class="status-row"><span class="badge">T</span><div><strong>Launch mode</strong><small id="launchMode">-</small></div></div>
         <div class="status-row"><span class="badge">C</span><div><strong>Codex args</strong><small id="codexArgs">-</small></div></div>
         <div class="status-row"><span class="badge warn">M</span><div><strong>Model strategy</strong><small>Codex-first now. Multi-model slots can be added later.</small></div></div>
       </div>
@@ -507,6 +508,7 @@ export function renderCockpitHtml() {
       el('confidence').textContent = state.analysis.confidence;
       el('stackHints').textContent = state.analysis.detectedStackHints.length ? state.analysis.detectedStackHints.join(', ') : 'default web stack';
       el('codexArgs').textContent = state.codexArgs;
+      el('launchMode').textContent = state.launchMode === 'new_terminal' ? 'New terminal window' : 'Same terminal handoff';
 
       var warningCount = state.care.checks.filter(function (check) { return !check.ok; }).length;
       var score = Math.max(0, Math.round(((state.care.checks.length - warningCount) / Math.max(1, state.care.checks.length)) * 100));
@@ -563,7 +565,7 @@ export function renderCockpitHtml() {
         headers: { 'content-type': 'application/json' },
         body: JSON.stringify({ request: el('requestInput').value })
       });
-      log(data.message + '\\n\\n' + data.command);
+      log(data.message + '\\n\\n' + data.command + '\\n\\nThe original terminal will continue as Codex.');
     }
     async function connectGithub() {
       var githubUrl = el('githubInput').value.trim();

package/dist/core/codexRuntime.js

@@ -26,38 +26,67 @@ export function buildCodexPrompt(request) {
     ].join("\n");
 }
 export function buildCodexCommand(input) {
-    const args = splitCommandArgs(input.codexArgs || getDefaultCodexArgs());
-    return ["codex", ...args, "-C", quoteArg(input.root), quoteArg(buildCodexPrompt(input.request))].join(" ");
+    return buildCodexCommandParts(input).command;
 }
-export function launchCodex(input) {
-    const args = splitCommandArgs(input.codexArgs || getDefaultCodexArgs());
-    const prompt = buildCodexPrompt(input.request);
-    const command = buildCodexCommand(input);
+export function launchCodexInCurrentTerminal(input) {
+    const parts = buildCodexCommandParts(input);
+    try {
+        const child = platform() === "win32"
+            ? spawn("cmd.exe", ["/d", "/s", "/c", "codex", ...parts.args, "-C", input.root, parts.prompt], {
+                cwd: input.root,
+                stdio: "inherit",
+            })
+            : spawn("codex", [...parts.args, "-C", input.root, parts.prompt], {
+                cwd: input.root,
+                stdio: "inherit",
+            });
+        child.on("exit", (code) => {
+            process.exit(code ?? 0);
+        });
+        child.on("error", (error) => {
+            console.error(`Could not start Codex: ${error.message}`);
+            console.error(parts.command);
+            process.exit(1);
+        });
+        return { ok: true, command: parts.command, message: "Mission Control handed off to Codex in this terminal." };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown Codex launch failure.";
+        return { ok: false, command: parts.command, message };
+    }
+}
+export function launchCodexInNewTerminal(input) {
+    const parts = buildCodexCommandParts(input);
     try {
         if (platform() === "win32") {
-            const child = spawn("cmd.exe", ["/c", "start", "Gaslighting Codex", "/D", input.root, "codex", ...args, "-C", input.root, prompt], {
+            const child = spawn("cmd.exe", ["/c", "start", "Gaslighting Codex", "/D", input.root, "codex", ...parts.args, "-C", input.root, parts.prompt], {
                 cwd: input.root,
                 detached: true,
                 stdio: "ignore",
             });
             child.unref();
-            return { ok: true, command, message: "Started Codex in a new terminal window." };
+            return { ok: true, command: parts.command, message: "Started Codex in a new terminal window." };
         }
         if (platform() === "darwin") {
-            const script = `tell application "Terminal" to do script ${JSON.stringify(`cd ${quoteShell(input.root)} && ${command}`)}`;
+            const script = `tell application "Terminal" to do script ${JSON.stringify(`cd ${quoteShell(input.root)} && ${parts.command}`)}`;
             const child = spawn("osascript", ["-e", script], { detached: true, stdio: "ignore" });
             child.unref();
-            return { ok: true, command, message: "Started Codex in Terminal." };
+            return { ok: true, command: parts.command, message: "Started Codex in Terminal." };
         }
-        const child = spawn("sh", ["-lc", `cd ${quoteShell(input.root)} && ${command}`], { detached: true, stdio: "ignore" });
+        const child = spawn("sh", ["-lc", `cd ${quoteShell(input.root)} && ${parts.command}`], { detached: true, stdio: "ignore" });
         child.unref();
-        return { ok: true, command, message: "Started Codex in the background. If no terminal appears, copy the command and run it manually." };
+        return { ok: true, command: parts.command, message: "Started Codex in the background. If no terminal appears, copy the command and run it manually." };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : "Unknown Codex launch failure.";
-        return { ok: false, command, message };
+        return { ok: false, command: parts.command, message };
     }
 }
+function buildCodexCommandParts(input) {
+    const args = splitCommandArgs(input.codexArgs || getDefaultCodexArgs());
+    const prompt = buildCodexPrompt(input.request);
+    return { args, prompt, command: ["codex", ...args, "-C", quoteArg(input.root), quoteArg(prompt)].join(" ") };
+}
 export function splitCommandArgs(input) {
     const args = [];
     const pattern = /"([^"]*)"|'([^']*)'|(\S+)/g;

package/dist/version.js

@@ -1,2 +1,2 @@
 export const packageName = "gaslighting-engine";
-export const packageVersion = "0.3.0";
+export const packageVersion = "0.3.1";

package/docs/codex-usage.md

@@ -54,6 +54,14 @@ Generate documents and open Mission Control:
 npx gaslighting-engine@latest start "I want to build a hospital website."
 ```
 
+`Start Codex` continues in the same terminal by default. Use `--new-terminal` only when you intentionally want a separate terminal window.
+
+Custom Codex flags:
+
+```bash
+npx gaslighting-engine@latest start "I want to build a hospital website." --codex-args="--search --dangerously-bypass-approvals-and-sandbox"
+```
+
 Open the GUI for an existing Gaslighting project:
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gaslighting-engine",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "LUDGI Gaslighting-engine: a hardcore project-discipline generator for AI coding agents.",
   "type": "module",
   "license": "MIT",