gaslighting-engine 0.3.1 → 0.4.1

package/dist/core/generateStructuredDocs.js

@@ -0,0 +1,405 @@
+import { pageList, projectPurpose, stackSummary, decisionDate } from "./content.js";
+import { generateProjectCareMarkdown } from "./projectCare.js";
+import { generatePrdMarkdown } from "./generatePrdMarkdown.js";
+export function generateStructuredDocs(input, analysis, root) {
+    const pages = pageList(analysis.projectType);
+    const purpose = projectPurpose(analysis.projectType);
+    const primaryPages = pages.slice(0, 8);
+    return [
+        { filename: ".gaslighting/config.json", content: gaslightingConfigJson(input) },
+        { filename: ".agents/config.json", content: agentsConfigJson(input) },
+        { filename: ".agents/runtimes/codex.json", content: runtimeConfig("codex", true, true) },
+        { filename: ".agents/runtimes/claude.json", content: runtimeConfig("claude", true, true) },
+        { filename: ".agents/runtimes/qwen.json", content: runtimeConfig("qwen", true, false) },
+        { filename: ".agents/runtimes/kimi.json", content: runtimeConfig("kimi", true, true) },
+        { filename: ".agents/runtimes/opencode.json", content: runtimeConfig("opencode", true, false) },
+        { filename: ".agents/runtimes/openai_compatible.json", content: runtimeConfig("openai_compatible", false, false) },
+        { filename: ".agents/runtimes/local.json", content: runtimeConfig("local", false, false) },
+        { filename: ".agents/mcp/manifest.json", content: mcpManifestJson() },
+        { filename: ".gaslighting/INDEX.md", content: indexMarkdown(input, analysis, pages) },
+        { filename: ".gaslighting/mission/PROJECT_PURPOSE.md", content: projectPurposeMarkdown(input, analysis, purpose) },
+        { filename: ".gaslighting/mission/EXECUTION_RULES.md", content: executionRulesMarkdown(input) },
+        { filename: ".gaslighting/mission/COMPLETION_STANDARD.md", content: completionStandardMarkdown() },
+        { filename: ".gaslighting/product/PRD.md", content: generatePrdMarkdown(input, analysis) },
+        { filename: ".gaslighting/product/USER_FLOWS.md", content: userFlowsMarkdown(analysis, pages) },
+        { filename: ".gaslighting/product/PAGE_MAP.md", content: pageMapMarkdown(pages) },
+        { filename: ".gaslighting/features/core-scope/FEATURE.md", content: featureMarkdown(input, analysis) },
+        { filename: ".gaslighting/features/core-scope/TASKS.md", content: tasksMarkdown(input, analysis, primaryPages) },
+        { filename: ".gaslighting/features/core-scope/DECISIONS.md", content: featureDecisionsMarkdown(analysis) },
+        { filename: ".gaslighting/features/core-scope/RISKS.md", content: featureRisksMarkdown(analysis) },
+        ...primaryPages.flatMap((page) => pageDocs(page, analysis)),
+        { filename: ".gaslighting/operations/GIT.md", content: operationGitMarkdown(root) },
+        { filename: ".gaslighting/operations/GITHUB.md", content: operationGitHubMarkdown(root) },
+        { filename: ".gaslighting/operations/DOMAIN.md", content: operationDomainMarkdown() },
+        { filename: ".gaslighting/operations/DEPLOYMENT.md", content: operationDeploymentMarkdown() },
+        { filename: ".gaslighting/operations/ENV.md", content: operationEnvMarkdown() },
+        { filename: ".gaslighting/decisions/ADR-0001-stack.md", content: adrStackMarkdown(analysis) },
+        { filename: ".gaslighting/decisions/ADR-0002-agent-runtime.md", content: adrAgentRuntimeMarkdown(input) },
+        { filename: ".gaslighting/tasks/TASK-0001.md", content: firstTaskMarkdown(input, analysis) },
+        { filename: ".gaslighting/loops/current-session.json", content: loopSessionJson(input) },
+        { filename: ".gaslighting/checkpoints/latest.md", content: checkpointMarkdown(input) },
+        { filename: ".gaslighting/verification/latest-report.md", content: verificationReportMarkdown() },
+        { filename: ".gaslighting/memory/PROJECT_MEMORY.md", content: projectMemoryMarkdown(input, analysis) },
+        { filename: ".gaslighting/memory/SESSION_LOG.md", content: sessionLogMarkdown(input) },
+        { filename: ".gaslighting/memory/OPEN_QUESTIONS.md", content: openQuestionsMarkdown(analysis) },
+        { filename: ".gaslighting/operations/PROJECT_CARE.md", content: generateProjectCareMarkdown(input, analysis, root) },
+    ];
+}
+function gaslightingConfigJson(input) {
+    return `${JSON.stringify({
+        defaultRuntime: input.runtime ?? "codex",
+        loopMode: input.loopMode ?? "off",
+        permissionMode: input.permissionMode ?? "auto_review",
+        skillSource: ".agents",
+        documentLayout: "structured",
+    }, null, 2)}\n`;
+}
+function agentsConfigJson(input) {
+    return `${JSON.stringify({
+        sourceOfTruth: true,
+        defaultRuntime: input.runtime ?? "codex",
+        permissionMode: input.permissionMode ?? "auto_review",
+        exports: [".codex"],
+        skillRoot: ".agents/skills",
+        mcpRoot: ".agents/mcp",
+    }, null, 2)}\n`;
+}
+function runtimeConfig(id, supportsMcp, supportsSkills) {
+    return `${JSON.stringify({ id, enabled: id === "codex", supportsMcp, supportsSkills }, null, 2)}\n`;
+}
+function mcpManifestJson() {
+    return `${JSON.stringify({ servers: [], installedAt: null, source: ".agents/mcp" }, null, 2)}\n`;
+}
+function indexMarkdown(input, analysis, pages) {
+    return `# Gaslighting-engine Index
+
+This is the structured source of truth for the project discipline layer.
+
+## Mission
+
+- Original request: ${input.rawUserRequest}
+- Project type: ${analysis.projectType}
+- Classification confidence: ${analysis.confidence}
+- Default runtime: ${input.runtime ?? "codex"}
+- Loop mode: ${input.loopMode ?? "off"}
+- Permission mode: ${input.permissionMode ?? "auto_review"}
+
+## Read Order For Agents
+
+1. \`mission/PROJECT_PURPOSE.md\`
+2. \`mission/EXECUTION_RULES.md\`
+3. \`mission/COMPLETION_STANDARD.md\`
+4. \`product/PRD.md\`
+5. \`product/PAGE_MAP.md\`
+6. \`features/core-scope/TASKS.md\`
+7. \`operations/PROJECT_CARE.md\`
+8. \`loops/current-session.json\`
+
+## Pages
+
+${pages.map((page) => `- ${page}`).join("\n")}
+
+## Compatibility Files
+
+Older agents may still read the root compatibility markdown files in \`.gaslighting/\`. Those files remain generated for backward compatibility, but this index is the preferred entrypoint.
+`;
+}
+function projectPurposeMarkdown(input, analysis, purpose) {
+    return `# Project Purpose
+
+Original request:
+
+> ${input.rawUserRequest}
+
+Project type: \`${analysis.projectType}\`
+
+The purpose is:
+
+${purpose.map((item) => `- ${item}`).join("\n")}
+
+Do not turn this project into a generic showcase. Preserve the business purpose and conversion/operation goals implied by the project type.
+`;
+}
+function executionRulesMarkdown(input) {
+    return `# Execution Rules
+
+- Runtime: ${input.runtime ?? "codex"}
+- Loop mode: ${input.loopMode ?? "off"}
+- Permission mode: ${input.permissionMode ?? "auto_review"}
+
+## Non-Negotiables
+
+- Do the actual work.
+- Do not shrink scope.
+- Do not use TODOs as fake implementation.
+- Do not present representative examples as full coverage.
+- Document missing information and continue unless truly blocked.
+- Record operational risk in \`operations/PROJECT_CARE.md\`.
+
+## Permission Modes
+
+- \`ask_each_task\`: request approval before each task action.
+- \`auto_review\`: continue ordinary work; request approval for destructive, publishing, deployment, secret, DNS, payment, MCP install, or global configuration changes.
+- \`full_autonomy\`: continue without approval, but log every action and never expose secrets.
+`;
+}
+function completionStandardMarkdown() {
+    return `# Completion Standard
+
+A task is complete only when:
+
+- Requested scope is fully handled.
+- No required item was silently skipped.
+- No placeholder is pretending to be implementation.
+- No TODO replaces requested implementation.
+- Verification was run or the reason it could not run is stated.
+- Assumptions, missing information, and operational care risks are updated.
+- The result can actually be used.
+`;
+}
+function userFlowsMarkdown(analysis, pages) {
+    return `# User Flows
+
+Project type: \`${analysis.projectType}\`
+
+## Primary Flow
+
+1. User lands on the first relevant page.
+2. User understands the offer or purpose quickly.
+3. User explores the page or feature set needed for trust and decision-making.
+4. User completes the primary conversion or operational action.
+
+## Page Coverage
+
+${pages.map((page, index) => `${index + 1}. ${page}`).join("\n")}
+`;
+}
+function pageMapMarkdown(pages) {
+    return `# Page Map
+
+${pages.map((page) => `- [ ] ${page}: define purpose, content, CTA, empty state, and acceptance criteria.`).join("\n")}
+`;
+}
+function featureMarkdown(input, analysis) {
+    return `# Core Scope Feature
+
+Original request: ${input.rawUserRequest}
+
+This feature captures the complete MVP scope for \`${analysis.projectType}\`.
+
+The agent must not reduce it to a sample, scaffold, or visual-only shell.
+`;
+}
+function tasksMarkdown(input, analysis, pages) {
+    return `# Core Scope Tasks
+
+- [ ] Preserve and restate the project purpose for \`${analysis.projectType}\`.
+- [ ] Implement all required MVP pages or feature surfaces.
+${pages.map((page) => `- [ ] Implement and verify page/surface: ${page}`).join("\n")}
+- [ ] Verify build/test/lint/browser flow as appropriate.
+- [ ] Update decisions, missing info, memory, and project care files.
+
+Original request:
+
+> ${input.rawUserRequest}
+`;
+}
+function featureDecisionsMarkdown(analysis) {
+    return `# Feature Decisions
+
+- Project type initialized as \`${analysis.projectType}\`.
+- Deterministic template generation is used instead of an LLM API.
+- Scope preservation is mandatory.
+`;
+}
+function featureRisksMarkdown(analysis) {
+    return `# Feature Risks
+
+- Classification confidence: ${analysis.confidence}
+- Missing information can affect copy, data model, page details, and production readiness.
+- Repetitive surfaces are at risk of being summarized instead of implemented.
+`;
+}
+function pageDocs(page, analysis) {
+    const slug = slugify(page);
+    return [
+        {
+            filename: `.gaslighting/pages/${slug}/PAGE_PRD.md`,
+            content: `# ${page} Page PRD
+
+Project type: \`${analysis.projectType}\`
+
+## Purpose
+
+This page must support the project purpose and not become decorative filler.
+
+## Required Coverage
+
+- Clear user goal.
+- Clear content hierarchy.
+- Clear CTA or operational action.
+- Mobile usability.
+- Empty/error states when relevant.
+`,
+        },
+        {
+            filename: `.gaslighting/pages/${slug}/ACCEPTANCE.md`,
+            content: `# ${page} Acceptance Criteria
+
+- [ ] Page purpose is visible.
+- [ ] Required content is not placeholder-only.
+- [ ] CTA or operational action is usable.
+- [ ] Mobile layout is usable.
+- [ ] No TODO replaces implementation.
+`,
+        },
+    ];
+}
+function operationGitMarkdown(root) {
+    return `# Git Operations
+
+Project root: \`${root}\`
+
+- Keep meaningful checkpoints.
+- Do not rewrite user changes.
+- Record remote changes in decisions.
+`;
+}
+function operationGitHubMarkdown(root) {
+    return `# GitHub Operations
+
+Project root: \`${root}\`
+
+- If no GitHub remote exists, ask for the GitHub URL and offer to connect it.
+- If a remote exists, preserve it unless the user explicitly asks to replace it.
+- Push only when permission mode allows it or approval is granted.
+`;
+}
+function operationDomainMarkdown() {
+    return `# Domain Operations
+
+- Production domain: missing until confirmed.
+- DNS provider: missing until confirmed.
+- Domain owner: missing until confirmed.
+- Do not treat missing domain data as implementation-blocking unless launch is requested.
+`;
+}
+function operationDeploymentMarkdown() {
+    return `# Deployment Operations
+
+- Deployment provider: unconfirmed until detected or selected.
+- Preview URL policy: missing until confirmed.
+- Rollback path: missing until confirmed.
+- Deployment commands require approval in auto-review mode.
+`;
+}
+function operationEnvMarkdown() {
+    return `# Environment Operations
+
+- Keep real secrets out of generated documents.
+- Prefer \`.env.example\` for required variables.
+- Secret changes require approval in auto-review mode.
+`;
+}
+function adrStackMarkdown(analysis) {
+    return `# ADR-0001: Stack Policy
+
+Date: ${decisionDate()}
+
+## Decision
+
+${stackSummary(analysis)}
+
+## Consequence
+
+The agent must avoid over-engineering and choose technology that serves the project purpose.
+`;
+}
+function adrAgentRuntimeMarkdown(input) {
+    return `# ADR-0002: Agent Runtime
+
+Date: ${decisionDate()}
+
+## Decision
+
+Default runtime is \`${input.runtime ?? "codex"}\`.
+
+Loop mode defaults to \`${input.loopMode ?? "off"}\`.
+
+Permission mode defaults to \`${input.permissionMode ?? "auto_review"}\`.
+`;
+}
+function firstTaskMarkdown(input, analysis) {
+    return `# TASK-0001: Initialize Mission Scope
+
+Status: pending
+Runtime: ${input.runtime ?? "codex"}
+Permission mode: ${input.permissionMode ?? "auto_review"}
+
+## Goal
+
+Turn the original request into implemented project work without fake completion.
+
+## Request
+
+> ${input.rawUserRequest}
+
+## Project Type
+
+\`${analysis.projectType}\`
+`;
+}
+function loopSessionJson(input) {
+    return `${JSON.stringify({
+        active: input.loopMode === "on",
+        status: input.loopMode === "on" ? "ready" : "off",
+        currentTask: "TASK-0001",
+        runtime: input.runtime ?? "codex",
+        permissionMode: input.permissionMode ?? "auto_review",
+        iterations: 0,
+        stopRequested: false,
+    }, null, 2)}\n`;
+}
+function checkpointMarkdown(input) {
+    return `# Latest Checkpoint
+
+No loop iteration has completed yet.
+
+Original request:
+
+> ${input.rawUserRequest}
+`;
+}
+function verificationReportMarkdown() {
+    return `# Latest Verification Report
+
+No verification has run yet.
+`;
+}
+function projectMemoryMarkdown(input, analysis) {
+    return `# Project Memory
+
+- Original request: ${input.rawUserRequest}
+- Project type: ${analysis.projectType}
+- Classification confidence: ${analysis.confidence}
+`;
+}
+function sessionLogMarkdown(input) {
+    return `# Session Log
+
+- ${decisionDate()}: Gaslighting-engine structured mission initialized for: ${input.rawUserRequest}
+`;
+}
+function openQuestionsMarkdown(analysis) {
+    return `# Open Questions
+
+${analysis.missingInfo.map((item) => `- ${item.item}: ${item.recommendedAction}`).join("\n") || "- No open questions recorded yet."}
+`;
+}
+function slugify(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 64) || "page";
+}

package/dist/core/mcpRegistry.js

@@ -0,0 +1,103 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+const registry = [
+    {
+        id: "github",
+        label: "GitHub",
+        description: "Repository, issue, pull request, and code review operations.",
+        url: "https://api.githubcopilot.com/mcp/",
+        runtimes: ["codex", "claude", "qwen", "opencode"],
+    },
+    {
+        id: "vercel",
+        label: "Vercel",
+        description: "Deployments, domains, logs, projects, and environment variables.",
+        url: "https://mcp.vercel.com",
+        runtimes: ["codex", "claude", "qwen", "opencode"],
+    },
+    {
+        id: "postgres",
+        label: "PostgreSQL",
+        description: "Database schema and readonly query workflows through dbhub.",
+        command: "npx",
+        args: ["-y", "@bytebase/dbhub"],
+        runtimes: ["codex", "claude", "qwen", "opencode"],
+    },
+    {
+        id: "figma",
+        label: "Figma",
+        description: "Design context and component handoff workflows.",
+        url: "https://mcp.figma.com/mcp",
+        runtimes: ["codex", "claude", "qwen", "opencode"],
+    },
+];
+export function searchMcpServers(query) {
+    const normalized = query.toLowerCase();
+    return registry.filter((server) => `${server.id} ${server.label} ${server.description}`.toLowerCase().includes(normalized));
+}
+export function listInstalledMcpServers(root) {
+    const manifest = readManifest(root);
+    return manifest.servers;
+}
+export function installMcpServer(root, id, runtime) {
+    const server = registry.find((item) => item.id === id);
+    if (!server)
+        return { ok: false, message: `Unknown MCP server: ${id}` };
+    const manifest = readManifest(root);
+    manifest.servers = [...manifest.servers.filter((item) => item.id !== server.id), server];
+    writeJson(join(root, ".agents", "mcp", "manifest.json"), manifest);
+    exportMcp(root, server, runtime);
+    return { ok: true, message: `Installed ${server.label} MCP definition for ${runtime}.` };
+}
+export function doctorMcp(root) {
+    const installed = listInstalledMcpServers(root);
+    return [
+        {
+            ok: existsSync(join(root, ".agents", "mcp", "manifest.json")),
+            message: ".agents/mcp/manifest.json exists.",
+        },
+        {
+            ok: installed.length > 0,
+            message: installed.length > 0 ? `${installed.length} MCP server definition(s) installed.` : "No MCP servers installed yet.",
+        },
+    ];
+}
+function exportMcp(root, server, runtime) {
+    if (runtime === "codex") {
+        const path = join(root, ".codex", "config.toml");
+        const body = server.url
+            ? `[mcp_servers.${server.id}]\nurl = "${server.url}"\n`
+            : `[mcp_servers.${server.id}]\ncommand = "${server.command}"\nargs = [${(server.args ?? []).map((arg) => `"${arg}"`).join(", ")}]\n`;
+        appendUnique(path, body, `[mcp_servers.${server.id}]`);
+    }
+    if (runtime === "claude") {
+        const path = join(root, ".mcp.json");
+        const existing = existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : { mcpServers: {} };
+        existing.mcpServers[server.id] = server.url ? { type: "http", url: server.url } : { command: server.command, args: server.args ?? [] };
+        writeJson(path, existing);
+    }
+}
+function readManifest(root) {
+    const path = join(root, ".agents", "mcp", "manifest.json");
+    if (!existsSync(path))
+        return { servers: [] };
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return { servers: [] };
+    }
+}
+function appendUnique(path, body, marker) {
+    const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
+    if (existing.includes(marker))
+        return;
+    writeText(path, `${existing.trimEnd()}\n\n${body}`.trimStart());
+}
+function writeJson(path, data) {
+    writeText(path, `${JSON.stringify(data, null, 2)}\n`);
+}
+function writeText(path, content) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content, "utf8");
+}

package/dist/core/missionLoop.js

@@ -0,0 +1,179 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentRuntimeAdapter } from "../agent-runtimes/registry.js";
+import { reviewPermission } from "../agent-runtimes/permissions.js";
+import { generateDocs } from "./generateDocs.js";
+import { writeDocs } from "../utils/file.js";
+import { decisionDate } from "./content.js";
+const sessionFile = ".gaslighting/loops/current-session.json";
+export function startMissionLoop(options) {
+    const request = options.request || "Continue the current Gaslighting mission without shrinking scope.";
+    const input = {
+        rawUserRequest: request,
+        runtime: options.runtime ?? "codex",
+        permissionMode: options.permissionMode ?? "auto_review",
+        loopMode: "on",
+        mode: "hardcore",
+        fullScope: true,
+        noTodo: true,
+        noShortcut: true,
+        force: true,
+    };
+    writeDocs(options.root, generateDocs(input, options.root).docs, true, false);
+    const session = {
+        active: true,
+        status: "ready",
+        request,
+        currentTask: "TASK-0001",
+        runtime: input.runtime ?? "codex",
+        permissionMode: input.permissionMode ?? "auto_review",
+        loopMode: "on",
+        iterations: 0,
+        retryCount: 0,
+        stopRequested: false,
+        lastMessage: "Mission loop started.",
+    };
+    saveLoopSession(options.root, session);
+    return session;
+}
+export function getMissionLoopStatus(root) {
+    return readLoopSession(root);
+}
+export function stopMissionLoop(root) {
+    const session = readLoopSession(root) ?? defaultStoppedSession();
+    session.active = false;
+    session.stopRequested = true;
+    session.status = "stopped";
+    session.lastMessage = "Mission loop stop requested.";
+    saveLoopSession(root, session);
+    appendSessionLog(root, "Mission loop stopped.");
+    return session;
+}
+export function resumeMissionLoop(options) {
+    let session = readLoopSession(options.root);
+    if (!session) {
+        session = startMissionLoop({ ...options, request: options.request || "Continue the current Gaslighting mission." });
+    }
+    if (session.stopRequested) {
+        session.stopRequested = false;
+        session.active = true;
+        session.status = "ready";
+    }
+    const maxIterations = Math.max(1, options.maxIterations ?? 1);
+    for (let index = 0; index < maxIterations; index += 1) {
+        if (!session.active || session.stopRequested)
+            break;
+        session = runOneIteration(options.root, session, Boolean(options.approve), options.extraArgs);
+        if (session.status === "approval_required" || session.status === "failed")
+            break;
+    }
+    saveLoopSession(options.root, session);
+    return session;
+}
+function runOneIteration(root, session, approved, extraArgs) {
+    const adapter = getAgentRuntimeAdapter(session.runtime);
+    const action = adapter.buildCommand({
+        root,
+        request: `${session.request}\n\nWork only on ${session.currentTask}. Update Gaslighting loop state honestly.`,
+        runtime: session.runtime,
+        permissionMode: session.permissionMode,
+        loopMode: "on",
+        extraArgs,
+    });
+    const review = reviewPermission(session.permissionMode, action);
+    if (review.requiresApproval && !approved) {
+        return {
+            ...session,
+            status: "approval_required",
+            lastMessage: review.reason,
+        };
+    }
+    const spawnInput = adapter.buildSpawn({
+        root,
+        request: `${session.request}\n\nWork only on ${session.currentTask}. Update Gaslighting loop state honestly.`,
+        runtime: session.runtime,
+        permissionMode: session.permissionMode,
+        loopMode: "on",
+        extraArgs,
+    });
+    saveLoopSession(root, { ...session, status: "running", lastMessage: `Running ${session.currentTask} with ${adapter.label}.` });
+    const startedAt = new Date().toISOString();
+    const result = spawnSync(spawnInput.file, spawnInput.args, { cwd: spawnInput.cwd, encoding: "utf8", stdio: "pipe" });
+    const endedAt = new Date().toISOString();
+    const ok = result.status === 0;
+    const nextSession = {
+        ...session,
+        iterations: session.iterations + 1,
+        retryCount: ok ? 0 : session.retryCount + 1,
+        status: ok ? "ready" : "failed",
+        lastMessage: ok ? `${session.currentTask} iteration completed. Verification still required before claiming done.` : `${session.currentTask} iteration failed.`,
+    };
+    writeIteration(root, nextSession.iterations, {
+        task: session.currentTask,
+        runtime: session.runtime,
+        command: action,
+        startedAt,
+        endedAt,
+        exitCode: result.status,
+        stdout: redact(result.stdout ?? ""),
+        stderr: redact(result.stderr ?? ""),
+    });
+    writeVerification(root, ok, nextSession.lastMessage ?? "");
+    appendSessionLog(root, nextSession.lastMessage ?? "Loop iteration completed.");
+    return nextSession;
+}
+function readLoopSession(root) {
+    const path = join(root, sessionFile);
+    if (!existsSync(path))
+        return undefined;
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+function saveLoopSession(root, session) {
+    writeJson(join(root, sessionFile), session);
+}
+function writeIteration(root, iteration, data) {
+    writeJson(join(root, ".gaslighting", "loops", "iterations", `${String(iteration).padStart(4, "0")}.json`), data);
+}
+function writeVerification(root, ok, message) {
+    writeText(join(root, ".gaslighting", "verification", "latest-report.md"), `# Latest Verification Report
+
+- Date: ${decisionDate()}
+- Status: ${ok ? "pass" : "fail"}
+- Message: ${message}
+
+Loop verification confirms process exit only. The agent must still run project-specific build, test, lint, and browser checks before declaring final completion.
+`);
+}
+function appendSessionLog(root, message) {
+    const path = join(root, ".gaslighting", "memory", "SESSION_LOG.md");
+    const existing = existsSync(path) ? readFileSync(path, "utf8") : "# Session Log\n";
+    writeText(path, `${existing.trimEnd()}\n- ${decisionDate()}: ${message}\n`);
+}
+function writeJson(path, data) {
+    writeText(path, `${JSON.stringify(data, null, 2)}\n`);
+}
+function writeText(path, content) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content, "utf8");
+}
+function defaultStoppedSession() {
+    return {
+        active: false,
+        status: "stopped",
+        request: "No loop session exists.",
+        currentTask: "TASK-0001",
+        runtime: "codex",
+        permissionMode: "auto_review",
+        loopMode: "off",
+        iterations: 0,
+        retryCount: 0,
+        stopRequested: true,
+    };
+}
+function redact(value) {
+    return value
+        .replace(/npm_[A-Za-z0-9]+/g, "[REDACTED_NPM_TOKEN]")
+        .replace(/sk-[A-Za-z0-9_-]+/g, "[REDACTED_API_KEY]")
+        .slice(0, 20_000);
+}