gaslighting-engine 0.3.1 → 0.4.0

package/desktop-dist/assets/index-oFTvTTu8.css

@@ -0,0 +1 @@
+.xterm{cursor:text;-webkit-user-select:none;user-select:none;position:relative}.xterm.focus,.xterm:focus{outline:none}.xterm .xterm-helpers{z-index:5;position:absolute;top:0}.xterm .xterm-helper-textarea{opacity:0;z-index:-5;white-space:nowrap;resize:none;border:0;width:0;height:0;margin:0;padding:0;position:absolute;top:0;left:-9999em;overflow:hidden}.xterm .composition-view{color:#fff;white-space:nowrap;z-index:1;background:#000;display:none;position:absolute}.xterm .composition-view.active{display:block}.xterm .xterm-viewport{cursor:default;background-color:#000;position:absolute;inset:0;overflow-y:scroll}.xterm .xterm-screen{position:relative}.xterm .xterm-screen canvas{position:absolute;top:0;left:0}.xterm-char-measure-element{visibility:hidden;line-height:normal;display:inline-block;position:absolute;top:0;left:-9999em}.xterm.enable-mouse-events{cursor:default}.xterm.xterm-cursor-pointer,.xterm .xterm-cursor-pointer{cursor:pointer}.xterm.column-select.focus{cursor:crosshair}.xterm .xterm-accessibility:not(.debug),.xterm .xterm-message{z-index:10;color:#0000;pointer-events:none;position:absolute;inset:0}.xterm .xterm-accessibility-tree:not(.debug) ::selection{color:#0000}.xterm .xterm-accessibility-tree{-webkit-user-select:text;user-select:text;white-space:pre;font-family:monospace}.xterm .xterm-accessibility-tree>div{transform-origin:0;width:fit-content}.xterm .live-region{width:1px;height:1px;position:absolute;left:-9999px;overflow:hidden}.xterm-dim{opacity:1!important}.xterm-underline-1{text-decoration:underline}.xterm-underline-2{-webkit-text-decoration:underline double;text-decoration:underline double}.xterm-underline-3{-webkit-text-decoration:underline wavy;text-decoration:underline wavy}.xterm-underline-4{-webkit-text-decoration:underline dotted;text-decoration:underline dotted}.xterm-underline-5{-webkit-text-decoration:underline dashed;text-decoration:underline dashed}.xterm-overline{text-decoration:overline}.xterm-overline.xterm-underline-1{text-decoration:underline overline}.xterm-overline.xterm-underline-2{-webkit-text-decoration:overline double underline;text-decoration:overline double underline}.xterm-overline.xterm-underline-3{-webkit-text-decoration:overline wavy underline;text-decoration:overline wavy underline}.xterm-overline.xterm-underline-4{-webkit-text-decoration:overline dotted underline;text-decoration:overline dotted underline}.xterm-overline.xterm-underline-5{-webkit-text-decoration:overline dashed underline;text-decoration:overline dashed underline}.xterm-strikethrough{text-decoration:line-through}.xterm-screen .xterm-decoration-container .xterm-decoration{z-index:6;position:absolute}.xterm-screen .xterm-decoration-container .xterm-decoration.xterm-decoration-top-layer{z-index:7}.xterm-decoration-overview-ruler{z-index:8;pointer-events:none;position:absolute;top:0;right:0}.xterm-decoration-top{z-index:2;position:relative}.xterm .xterm-scrollable-element>.scrollbar{cursor:default}.xterm .xterm-scrollable-element>.scrollbar>.scra{cursor:pointer;font-size:11px!important}.xterm .xterm-scrollable-element>.visible{opacity:1;z-index:11;background:0 0;transition:opacity .1s linear}.xterm .xterm-scrollable-element>.invisible{opacity:0;pointer-events:none}.xterm .xterm-scrollable-element>.invisible.fade{transition:opacity .8s linear}.xterm .xterm-scrollable-element>.shadow{display:none;position:absolute}.xterm .xterm-scrollable-element>.shadow.top{width:100%;height:3px;box-shadow:var(--vscode-scrollbar-shadow,#000) 0 6px 6px -6px inset;display:block;top:0;left:3px}.xterm .xterm-scrollable-element>.shadow.left{width:3px;height:100%;box-shadow:var(--vscode-scrollbar-shadow,#000) 6px 0 6px -6px inset;display:block;top:3px;left:0}.xterm .xterm-scrollable-element>.shadow.top-left-corner{width:3px;height:3px;display:block;top:0;left:0}.xterm .xterm-scrollable-element>.shadow.top.left{box-shadow:var(--vscode-scrollbar-shadow,#000) 6px 0 6px -6px inset}:root{color:#191919;background:#f5f5f3;font-family:Inter,Segoe UI,Arial,sans-serif}*{box-sizing:border-box}body{min-width:1000px;min-height:720px;margin:0}button,input,select,textarea{font:inherit}button{color:#191919;cursor:pointer;background:#fff;border:1px solid #d7d7d2;border-radius:6px;justify-content:center;align-items:center;gap:7px;height:36px;padding:0 12px;display:inline-flex}button:hover{border-color:#a7a7a0}.primary{color:#fff;background:#111;border-color:#111}.app-shell{grid-template-columns:248px 1fr;height:100vh;display:grid}.sidebar{background:#eceff1;border-right:1px solid #d8dddf;padding:22px 16px}.brand{align-items:center;gap:12px;margin-bottom:28px;display:flex}.brand-mark{color:#fff;background:#111;border-radius:8px;place-items:center;width:38px;height:38px;font-weight:800;display:grid}.brand strong,.brand span{display:block}.brand span{color:#667078;font-size:13px}.nav-button{background:0 0;border-color:#0000;justify-content:flex-start;width:100%;margin-bottom:8px}.nav-button.active,.nav-button:hover{background:#fff;border-color:#d7d7d2}.workspace{min-width:0;padding:26px;overflow:auto}.topbar{justify-content:space-between;align-items:flex-start;margin-bottom:22px;display:flex}.topbar h1{margin:0 0 6px;font-size:24px}.topbar p{color:#667078;margin:0;font-size:13px}.top-actions,.button-row,.control-row,.inline-form{flex-wrap:wrap;align-items:center;gap:10px;display:flex}.mission-grid{grid-template-columns:minmax(520px,1fr) 330px;align-items:stretch;gap:18px;display:grid}.mission-panel,.status-panel,.domain-panel,.terminal-panel{background:#fff;border:1px solid #deded8;border-radius:8px;padding:16px}.mission-panel label{color:#555d63;margin:0 0 7px;font-size:13px;display:block}textarea{resize:vertical;border:1px solid #d7d7d2;border-radius:6px;width:100%;min-height:132px;margin-bottom:12px;padding:12px}input,select{background:#fff;border:1px solid #d7d7d2;border-radius:6px;min-width:170px;height:36px;padding:0 10px}.mission-panel input{width:100%;margin-bottom:12px}.status-panel h2,.domain-panel h2,.terminal-panel h2{align-items:center;gap:8px;margin:0 0 14px;font-size:16px;display:flex}.status-line,.care-line{border-top:1px solid #f0f0ec;grid-template-columns:12px minmax(110px,1fr) auto;align-items:center;gap:10px;min-height:34px;display:grid}.care-line{grid-template-columns:12px 1fr;align-items:start;padding:9px 0}.care-line strong{font-size:13px;display:block}.care-line p{color:#667078;margin:3px 0 0;font-size:12px}.dot{border-radius:999px;width:9px;height:9px;margin-top:5px}.dot.ok{background:#138a48}.dot.warn{background:#d88700}.lower-grid{grid-template-columns:1fr 1fr;gap:18px;margin-top:18px;display:grid}.terminal-panel{grid-column:1/-1}.terminal-host{background:#111;border-radius:6px;height:300px;padding:8px;overflow:hidden}.list-box{flex-wrap:wrap;gap:8px;min-height:42px;margin:12px 0;display:flex}.list-box button{height:32px}@media (width<=1100px){.app-shell{grid-template-columns:200px 1fr}.mission-grid,.lower-grid{grid-template-columns:1fr}}

package/desktop-dist/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Gaslighting Mission Control</title>
+    <script type="module" crossorigin src="/assets/index-BoI6eWtN.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-oFTvTTu8.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/dist/agent-runtimes/permissions.js

@@ -0,0 +1,34 @@
+const sensitivePatterns = [
+    /\bgit\s+push\b/i,
+    /\bnpm\s+publish\b/i,
+    /\bpnpm\s+publish\b/i,
+    /\byarn\s+npm\s+publish\b/i,
+    /\bvercel\s+(deploy|prod|promote)\b/i,
+    /\bnetlify\s+deploy\b/i,
+    /\bmigrate\b/i,
+    /\bprisma\s+migrate\b/i,
+    /\bdrizzle-kit\s+(push|migrate)\b/i,
+    /\brm\s+-rf\b/i,
+    /\bRemove-Item\b.+\b-Recurse\b/i,
+    /\b(del|erase)\b.+\/s\b/i,
+    /\b\.env\b/i,
+    /\b(secret|token|api[_-]?key|password)\b/i,
+    /\bdns\b/i,
+    /\bdomain\b/i,
+    /\bmcp\s+install\b/i,
+    /\bcodex\s+mcp\s+add\b/i,
+    /\bclaude\s+mcp\s+add\b/i,
+];
+export function reviewPermission(mode, action) {
+    if (mode === "full_autonomy") {
+        return { allowed: true, requiresApproval: false, reason: "Full autonomy is enabled. The action will still be logged." };
+    }
+    if (mode === "ask_each_task") {
+        return { allowed: false, requiresApproval: true, reason: "Basic permission mode requires approval for each task action." };
+    }
+    const sensitive = sensitivePatterns.some((pattern) => pattern.test(action));
+    if (sensitive) {
+        return { allowed: false, requiresApproval: true, reason: "Auto-review mode requires approval for sensitive operations." };
+    }
+    return { allowed: true, requiresApproval: false, reason: "Auto-review mode allows this non-sensitive operation." };
+}

package/dist/agent-runtimes/prompts.js

@@ -0,0 +1,30 @@
+export function buildAgentPrompt(request) {
+    return [
+        "Use the gaslighting skill or follow the Gaslighting-engine control files.",
+        "",
+        "Read these files before doing any implementation:",
+        "1. AGENTS.md",
+        "2. .gaslighting/INDEX.md",
+        "3. .gaslighting/mission/PROJECT_PURPOSE.md",
+        "4. .gaslighting/mission/EXECUTION_RULES.md",
+        "5. .gaslighting/product/PRD.md",
+        "6. .gaslighting/operations/GIT.md",
+        "7. .gaslighting/operations/DOMAIN.md",
+        "8. .gaslighting/loops/current-session.json",
+        "",
+        "Also read the compatibility files when present:",
+        "- .gaslighting/GASLIGHTING.md",
+        "- .gaslighting/PRD.md",
+        "- .gaslighting/STACK_POLICY.md",
+        "- .gaslighting/MISSING_INFO.md",
+        "- .gaslighting/ASSUMPTIONS.md",
+        "- .gaslighting/DECISION_LOG.md",
+        "- .gaslighting/MEMORY.md",
+        "- .gaslighting/AGENT_RUNTIME.md",
+        "- .gaslighting/PROJECT_CARE.md",
+        "",
+        `Project request: ${request}`,
+        "",
+        "Implement the requested work. Preserve full scope. Do not use TODOs as fake implementation. Do not deliver representative examples when full coverage is required. If something is incomplete, declare it explicitly.",
+    ].join("\n");
+}

package/dist/agent-runtimes/registry.js

@@ -0,0 +1,214 @@
+import { execFileSync, spawn } from "node:child_process";
+import { platform } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { splitCommandArgs } from "../core/codexRuntime.js";
+import { buildAgentPrompt } from "./prompts.js";
+const definitions = [
+    {
+        id: "codex",
+        label: "Codex CLI",
+        command: "codex",
+        supportsMcp: true,
+        supportsSkills: true,
+        models: [{ id: "codex-default", label: "Codex default", description: "Use the model configured by Codex." }],
+        buildArgs: (input, prompt) => [...splitCommandArgs(input.extraArgs || getDefaultCodexArgs()), "-C", input.root, prompt],
+    },
+    {
+        id: "claude",
+        label: "Claude Code",
+        command: "claude",
+        supportsMcp: true,
+        supportsSkills: true,
+        models: [{ id: "claude-default", label: "Claude default", description: "Use the model configured by Claude Code." }],
+        buildArgs: (input, prompt) => [...splitCommandArgs(input.extraArgs || ""), prompt],
+    },
+    {
+        id: "qwen",
+        label: "Qwen Code",
+        command: "qwen",
+        supportsMcp: true,
+        supportsSkills: false,
+        models: [{ id: "qwen-default", label: "Qwen default", description: "Use Qwen Code /model selection." }],
+        buildArgs: (input, prompt) => [...splitCommandArgs(input.extraArgs || ""), prompt],
+    },
+    {
+        id: "opencode",
+        label: "OpenCode",
+        command: "opencode",
+        supportsMcp: true,
+        supportsSkills: false,
+        models: [{ id: "opencode-default", label: "OpenCode default", description: "Use OpenCode's configured provider." }],
+        buildArgs: (input, prompt) => [...splitCommandArgs(input.extraArgs || ""), prompt],
+    },
+    {
+        id: "kimi",
+        label: "Kimi via compatible agent",
+        command: "claude",
+        supportsMcp: true,
+        supportsSkills: true,
+        models: [
+            { id: "kimi-k2.6", label: "Kimi K2.6", description: "Kimi's long-context coding and agent model." },
+            { id: "kimi-k2.5", label: "Kimi K2.5", description: "Fallback Kimi agent model." },
+        ],
+        buildArgs: (input, prompt) => [...splitCommandArgs(input.extraArgs || ""), prompt],
+    },
+    {
+        id: "openai_compatible",
+        label: "OpenAI-compatible API",
+        command: process.execPath,
+        supportsMcp: false,
+        supportsSkills: false,
+        models: [
+            { id: "gpt-5.3-codex", label: "GPT-5.3 Codex" },
+            { id: "kimi-k2.6", label: "Kimi K2.6" },
+            { id: "qwen-code-default", label: "Qwen provider default" },
+        ],
+        buildArgs: (input, prompt) => [resolveCliEntry(), "api-run", "--model", input.model || "gpt-5.3-codex", "--prompt", prompt],
+    },
+    {
+        id: "local",
+        label: "Local model",
+        command: "ollama",
+        supportsMcp: false,
+        supportsSkills: false,
+        models: [
+            { id: "qwen2.5-coder", label: "Qwen Coder local" },
+            { id: "gemma4", label: "Gemma 4 local" },
+        ],
+        buildArgs: (input, prompt) => ["run", input.model || "qwen2.5-coder", prompt],
+    },
+];
+export function listAgentRuntimeAdapters() {
+    return definitions.map(createAdapter);
+}
+export function getAgentRuntimeAdapter(runtime) {
+    const definition = definitions.find((item) => item.id === runtime) ?? definitions[0];
+    return createAdapter(definition);
+}
+export function detectAgentRuntimes() {
+    return listAgentRuntimeAdapters().map((adapter) => adapter.detect());
+}
+function createAdapter(definition) {
+    return {
+        id: definition.id,
+        label: definition.label,
+        command: definition.command,
+        supportsMcp: definition.supportsMcp,
+        supportsSkills: definition.supportsSkills,
+        detect: () => detectRuntime(definition),
+        listModels: () => definition.models,
+        buildCommand: (input) => buildDisplayCommand(definition, input),
+        buildSpawn: (input) => {
+            const prompt = buildAgentPrompt(input.request);
+            return { file: runtimeFile(definition.command), args: definition.buildArgs(input, prompt), cwd: input.root };
+        },
+        run: (input) => launchInCurrentTerminal(definition, input),
+    };
+}
+function detectRuntime(definition) {
+    if (definition.id === "openai_compatible") {
+        const hasKey = Boolean(process.env.OPENAI_COMPATIBLE_API_KEY || process.env.OPENAI_API_KEY || process.env.KIMI_API_KEY);
+        return {
+            id: definition.id,
+            label: definition.label,
+            available: hasKey,
+            command: process.execPath,
+            version: commandVersion(process.execPath),
+            message: hasKey ? "OpenAI-compatible API key is configured." : "Set OPENAI_COMPATIBLE_API_KEY, OPENAI_API_KEY, or KIMI_API_KEY to use direct API mode.",
+        };
+    }
+    if (definition.id === "kimi") {
+        const command = commandPath(definition.command);
+        const version = command ? commandVersion(definition.command) : undefined;
+        const hasEndpoint = Boolean(process.env.KIMI_API_KEY || process.env.MOONSHOT_API_KEY) ||
+            Boolean(process.env.ANTHROPIC_BASE_URL?.toLowerCase().includes("moonshot")) ||
+            Boolean(process.env.OPENAI_COMPATIBLE_BASE_URL?.toLowerCase().includes("moonshot"));
+        return {
+            id: definition.id,
+            label: definition.label,
+            available: Boolean(command && hasEndpoint),
+            command,
+            version,
+            message: !command
+                ? "Claude-compatible CLI is not installed or not on PATH."
+                : hasEndpoint
+                    ? `Kimi-compatible endpoint is configured${version ? ` (${version})` : ""}.`
+                    : "Install/configure a Kimi-compatible endpoint first: set KIMI_API_KEY, MOONSHOT_API_KEY, or a Moonshot base URL.",
+        };
+    }
+    const command = commandPath(definition.command);
+    const version = command ? commandVersion(definition.command) : undefined;
+    return {
+        id: definition.id,
+        label: definition.label,
+        available: Boolean(command),
+        command,
+        version,
+        message: command ? `${definition.label} is available${version ? ` (${version})` : ""}.` : `${definition.label} is not installed or not on PATH.`,
+    };
+}
+function launchInCurrentTerminal(definition, input) {
+    const spawnInput = createAdapter(definition).buildSpawn(input);
+    const command = buildDisplayCommand(definition, input);
+    try {
+        const child = platform() === "win32"
+            ? spawn("cmd.exe", ["/d", "/s", "/c", spawnInput.file, ...spawnInput.args], { cwd: spawnInput.cwd, stdio: "inherit" })
+            : spawn(spawnInput.file, spawnInput.args, { cwd: spawnInput.cwd, stdio: "inherit" });
+        child.on("exit", (code) => process.exit(code ?? 0));
+        child.on("error", (error) => {
+            console.error(`Could not start ${definition.label}: ${error.message}`);
+            console.error(command);
+            process.exit(1);
+        });
+        return { ok: true, command, message: `${definition.label} started in this terminal.` };
+    }
+    catch (error) {
+        return { ok: false, command, message: error instanceof Error ? error.message : `Could not start ${definition.label}.` };
+    }
+}
+function buildDisplayCommand(definition, input) {
+    const prompt = buildAgentPrompt(input.request);
+    return [definition.command, ...definition.buildArgs(input, prompt).map(quoteArg)].join(" ");
+}
+function getDefaultCodexArgs() {
+    return process.env.GASLIGHTING_CODEX_ARGS || "--search --dangerously-bypass-approvals-and-sandbox";
+}
+function runtimeFile(command) {
+    return command;
+}
+function commandPath(command) {
+    try {
+        const result = platform() === "win32"
+            ? execFileSync("where", [command], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] })
+            : execFileSync("sh", ["-lc", `command -v ${quoteShell(command)}`], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        return result.split(/\r?\n/).find(Boolean)?.trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+function commandVersion(command) {
+    for (const args of [["--version"], ["-v"]]) {
+        try {
+            const result = execFileSync(command, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 2000 }).trim();
+            if (result)
+                return result.split(/\r?\n/)[0];
+        }
+        catch {
+            // Try the next common version flag.
+        }
+    }
+    return undefined;
+}
+function resolveCliEntry() {
+    return join(dirname(fileURLToPath(import.meta.url)), "..", "index.js");
+}
+function quoteArg(value) {
+    if (/^[A-Za-z0-9_./:@=-]+$/.test(value))
+        return value;
+    return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("\n", "\\n")}"`;
+}
+function quoteShell(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}

package/dist/agent-runtimes/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -1,12 +1,17 @@
 import { Command, InvalidArgumentError } from "commander";
+import { runAgentDoctor, runAgentList } from "./commands/agent.js";
 import { runAgents } from "./commands/agents.js";
+import { runApiRun } from "./commands/apiRun.js";
 import { runCare } from "./commands/care.js";
 import { runCockpit, runCodexRun, runStart } from "./commands/cockpit.js";
 import { runCodexDoctor, runCodexInstall } from "./commands/codexInstall.js";
+import { runDesktop } from "./commands/desktop.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 { runLoopResume, runLoopStart, runLoopStatus, runLoopStop } from "./commands/loop.js";
+import { runMcpDoctor, runMcpInstall, runMcpList, runMcpSearch } from "./commands/mcp.js";
+import { runSkill, runSkillCreate, runSkillDoctor, runSkillInstall } from "./commands/skill.js";
 import { runUpdate } from "./commands/update.js";
 import { runUpgrade } from "./commands/upgrade.js";
 import { packageVersion } from "./version.js";
@@ -25,11 +30,23 @@ const projectTypes = [
     "education_site",
     "generic_web_project",
 ];
+const agentRuntimes = ["codex", "claude", "qwen", "kimi", "opencode", "openai_compatible", "local"];
+const permissionModes = ["ask_each_task", "auto_review", "full_autonomy"];
 function parseProjectType(value) {
     if (projectTypes.includes(value))
         return value;
     throw new InvalidArgumentError(`Invalid project type. Use one of: ${projectTypes.join(", ")}`);
 }
+function parseAgentRuntime(value) {
+    if (agentRuntimes.includes(value))
+        return value;
+    throw new InvalidArgumentError(`Invalid runtime. Use one of: ${agentRuntimes.join(", ")}`);
+}
+function parsePermissionMode(value) {
+    if (permissionModes.includes(value))
+        return value;
+    throw new InvalidArgumentError(`Invalid permission mode. Use one of: ${permissionModes.join(", ")}`);
+}
 function addCommonOptions(command) {
     return command
         .option("--hardcore", "generate aggressive anti-escape discipline (default)")
@@ -45,8 +62,19 @@ function addCommonOptions(command) {
         .option("--dry-run", "print files without writing")
         .option("--lang <lang>", "language: en or ko", "en")
         .option("--type <type>", "project type override", parseProjectType)
+        .option("--runtime <runtime>", "agent runtime", parseAgentRuntime, "codex")
+        .option("--permission-mode <mode>", "permission mode", parsePermissionMode, "auto_review")
         .option("--path <path>", "target directory");
 }
+function actionOptions(value) {
+    return typeof value.opts === "function" ? value.opts() : value;
+}
+function mergedActionOptions(parent, value) {
+    return removeUndefined({ ...parent.opts(), ...actionOptions(value) });
+}
+function removeUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
 export function buildCli() {
     const program = new Command();
     program
@@ -62,6 +90,10 @@ Examples:
   $ gaslighting-engine doctor
   $ gaslighting-engine care --github-url https://github.com/user/repo.git
   $ gaslighting-engine start "Build a hospital homepage"
+  $ gaslighting-engine desktop "Build a hospital homepage"
+  $ gaslighting-engine loop start "Build a hospital homepage"
+  $ gaslighting-engine agent list
+  $ gaslighting-engine mcp search github
   $ gaslighting-engine upgrade
   $ gaslighting-engine codex-install --force
 
@@ -81,13 +113,30 @@ Defaults:
         .description("Check whether the repository is properly disciplined")
         .option("--path <path>", "target directory")
         .action(runDoctor);
-    program
+    const skillCommand = program
         .command("skill")
-        .description("Generate only Codex Skill files")
+        .description("Generate, install, or inspect Gaslighting skills")
         .option("--force", "overwrite existing files")
         .option("--dry-run", "print files without writing")
         .option("--path <path>", "target directory")
         .action(runSkill);
+    skillCommand
+        .command("create <name>")
+        .description("Create a shared skill under .agents/skills")
+        .option("--path <path>", "target directory")
+        .option("--description <description>", "skill description")
+        .action((name, options) => runSkillCreate(name, mergedActionOptions(skillCommand, options)));
+    skillCommand
+        .command("install <name>")
+        .description("Export a shared skill into a runtime-specific skill location")
+        .option("--path <path>", "target directory")
+        .option("--runtime <runtime>", "target runtime", parseAgentRuntime, "codex")
+        .action((name, options) => runSkillInstall(name, mergedActionOptions(skillCommand, options)));
+    skillCommand
+        .command("doctor")
+        .description("Check shared skill and runtime export locations")
+        .option("--path <path>", "target directory")
+        .action((options) => runSkillDoctor(mergedActionOptions(skillCommand, options)));
     program
         .command("agents")
         .description("Generate or update AGENTS.md")
@@ -117,6 +166,9 @@ 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("--runtime <runtime>", "agent runtime", parseAgentRuntime, "codex")
+        .option("--permission-mode <mode>", "permission mode", parsePermissionMode, "auto_review")
+        .option("--loop <mode>", "loop mode: off or on", "off")
         .option("--new-terminal", "launch Codex in a separate terminal instead of handing off the current terminal")
         .action(runStart);
     program
@@ -131,6 +183,9 @@ 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("--runtime <runtime>", "agent runtime", parseAgentRuntime, "codex")
+        .option("--permission-mode <mode>", "permission mode", parsePermissionMode, "auto_review")
+        .option("--loop <mode>", "loop mode: off or on", "off")
         .option("--new-terminal", "launch Codex in a separate terminal instead of handing off the current terminal")
         .action(runCockpit);
     program
@@ -142,8 +197,72 @@ Defaults:
         .option("--lang <lang>", "language: en or ko", "en")
         .option("--type <type>", "project type override", parseProjectType)
         .option("--codex-args <args>", "Codex CLI args")
+        .option("--runtime <runtime>", "agent runtime", parseAgentRuntime, "codex")
+        .option("--permission-mode <mode>", "permission mode", parsePermissionMode, "auto_review")
+        .option("--loop <mode>", "loop mode: off or on", "off")
         .option("--new-terminal", "launch Codex in a separate terminal instead of handing off the current terminal")
         .action(runCodexRun);
+    program
+        .command("desktop [request]")
+        .description("Open the Electron Gaslighting Mission Control app")
+        .option("--path <path>", "target directory")
+        .option("--dev", "load the Vite dev server instead of built desktop assets")
+        .action(runDesktop);
+    const loopCommand = program.command("loop").description("Manage Mission Loop sessions");
+    loopCommand
+        .command("start [request]")
+        .description("Create a Mission Loop session")
+        .option("--path <path>", "target directory")
+        .option("--runtime <runtime>", "agent runtime", parseAgentRuntime, "codex")
+        .option("--permission-mode <mode>", "permission mode", parsePermissionMode, "auto_review")
+        .action((request, options) => runLoopStart(request, actionOptions(options)));
+    loopCommand
+        .command("status")
+        .description("Show Mission Loop status")
+        .option("--path <path>", "target directory")
+        .action((options) => runLoopStatus(actionOptions(options)));
+    loopCommand
+        .command("stop")
+        .description("Stop the Mission Loop")
+        .option("--path <path>", "target directory")
+        .action((options) => runLoopStop(actionOptions(options)));
+    loopCommand
+        .command("resume")
+        .description("Run the next Mission Loop iteration")
+        .option("--path <path>", "target directory")
+        .option("--runtime <runtime>", "agent runtime", parseAgentRuntime)
+        .option("--permission-mode <mode>", "permission mode", parsePermissionMode)
+        .option("--max-iterations <count>", "maximum iterations to run", "1")
+        .option("--approve", "approve the current iteration when permission mode requires approval")
+        .option("--extra-args <args>", "extra runtime args")
+        .action((options) => runLoopResume(actionOptions(options)));
+    const agentCommand = program.command("agent").description("Inspect available agent runtimes");
+    agentCommand.command("list").description("List runtimes").action(runAgentList);
+    agentCommand.command("doctor").description("Check runtime availability").action(runAgentDoctor);
+    const mcpCommand = program.command("mcp").description("Search, install, and inspect MCP definitions");
+    mcpCommand.command("search <query>").description("Search known MCP servers").action(runMcpSearch);
+    mcpCommand
+        .command("install <name>")
+        .description("Install an MCP definition into .agents and export for a runtime")
+        .option("--path <path>", "target directory")
+        .option("--runtime <runtime>", "target runtime", parseAgentRuntime, "codex")
+        .action((name, options) => runMcpInstall(name, actionOptions(options)));
+    mcpCommand
+        .command("list")
+        .description("List installed MCP definitions")
+        .option("--path <path>", "target directory")
+        .action((options) => runMcpList(actionOptions(options)));
+    mcpCommand
+        .command("doctor")
+        .description("Check MCP install state")
+        .option("--path <path>", "target directory")
+        .action((options) => runMcpDoctor(actionOptions(options)));
+    program
+        .command("api-run")
+        .description("Run a single OpenAI-compatible model call for internal desktop/provider workflows")
+        .option("--model <model>", "model id")
+        .option("--prompt <prompt>", "prompt")
+        .action(runApiRun);
     program
         .command("upgrade")
         .description("Update the local Codex Gaslighting install with one simple command")
@@ -174,7 +293,26 @@ 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", "care", "start", "cockpit", "run", "upgrade", "codex-install", "codex-doctor"]);
+    const commands = new Set([
+        "init",
+        "generate",
+        "update",
+        "doctor",
+        "skill",
+        "agents",
+        "care",
+        "start",
+        "cockpit",
+        "run",
+        "desktop",
+        "loop",
+        "agent",
+        "mcp",
+        "api-run",
+        "upgrade",
+        "codex-install",
+        "codex-doctor",
+    ]);
     const firstMeaningful = args.find((arg) => !arg.startsWith("-"));
     if (firstMeaningful && commands.has(firstMeaningful))
         return argv;

package/dist/commands/agent.js

@@ -0,0 +1,11 @@
+import { detectAgentRuntimes } from "../agent-runtimes/registry.js";
+import { printBanner } from "../utils/banner.js";
+export function runAgentList() {
+    printBanner("AGENT RUNTIMES");
+    for (const status of detectAgentRuntimes()) {
+        console.log(`${status.available ? "PASS" : "WARN"} ${status.label}: ${status.message}`);
+    }
+}
+export function runAgentDoctor() {
+    runAgentList();
+}

package/dist/commands/apiRun.js

@@ -0,0 +1,32 @@
+export async function runApiRun(options) {
+    const baseUrl = process.env.OPENAI_COMPATIBLE_BASE_URL || process.env.OPENAI_BASE_URL || "https://api.openai.com/v1";
+    const apiKey = process.env.OPENAI_COMPATIBLE_API_KEY || process.env.OPENAI_API_KEY || process.env.KIMI_API_KEY;
+    const model = options.model || "gpt-5.3-codex";
+    const prompt = options.prompt || "Read the Gaslighting-engine mission files and continue the project.";
+    if (!apiKey) {
+        console.log("OPENAI_COMPATIBLE_API_KEY, OPENAI_API_KEY, or KIMI_API_KEY is required for api-run.");
+        process.exitCode = 1;
+        return;
+    }
+    const response = await fetch(`${baseUrl.replace(/\/$/, "")}/chat/completions`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+            model,
+            messages: [
+                { role: "system", content: "You are running under Gaslighting-engine discipline. Do not fake completion." },
+                { role: "user", content: prompt },
+            ],
+        }),
+    });
+    if (!response.ok) {
+        console.log(`API run failed: ${response.status} ${await response.text()}`);
+        process.exitCode = 1;
+        return;
+    }
+    const data = (await response.json());
+    console.log(data.choices?.[0]?.message?.content || "No response content returned.");
+}