@prepcli/prepcli 0.1.0

package/src/lib/detect.js

@@ -0,0 +1,194 @@
+"use strict";
+
+const fs   = require("node:fs");
+const path = require("node:path");
+const { execSync } = require("node:child_process");
+
+function tryRead(filePath) {
+  try { return fs.readFileSync(filePath, "utf8"); }
+  catch { return null; }
+}
+
+function tryJSON(filePath) {
+  const raw = tryRead(filePath);
+  if (!raw) return null;
+  try { return JSON.parse(raw); } catch { return null; }
+}
+
+function exists(filePath) {
+  try { fs.accessSync(filePath); return true; }
+  catch { return false; }
+}
+
+function gitRemote(cwd) {
+  try {
+    return execSync("git remote get-url origin", { cwd, stdio: ["pipe", "pipe", "pipe"] })
+      .toString().trim();
+  } catch { return null; }
+}
+
+const FRAMEWORK_DEPS = {
+  "next":            "Next.js",
+  "@remix-run/node": "Remix",
+  "astro":           "Astro",
+  "gatsby":          "Gatsby",
+  "nuxt":            "Nuxt",
+  "@sveltejs/kit":   "SvelteKit",
+  "svelte":          "Svelte",
+  "vue":             "Vue",
+  "react":           "React",
+  "@nestjs/core":    "NestJS",
+  "fastify":         "Fastify",
+  "express":         "Express",
+  "koa":             "Koa",
+  "hono":            "Hono",
+  "electron":        "Electron",
+};
+
+const DB_DEPS = {
+  "@supabase/supabase-js": "Supabase",
+  "@prisma/client":        "Prisma",
+  "drizzle-orm":           "Drizzle",
+  "typeorm":               "TypeORM",
+  "mongoose":              "MongoDB",
+  "pg":                    "PostgreSQL",
+  "mysql2":                "MySQL",
+  "sqlite3":               "SQLite",
+  "redis":                 "Redis",
+  "@upstash/redis":        "Upstash Redis",
+};
+
+const AUTH_DEPS = {
+  "better-auth":    "better-auth",
+  "next-auth":      "NextAuth",
+  "@auth/core":     "Auth.js",
+  "passport":       "Passport",
+  "lucia":          "Lucia",
+};
+
+const TEST_DEPS = {
+  "vitest":     "Vitest",
+  "jest":       "Jest",
+  "playwright": "Playwright",
+  "cypress":    "Cypress",
+};
+
+const API_DEPS = {
+  "@trpc/server":          "tRPC",
+  "@tanstack/react-query": "TanStack Query",
+};
+
+const STYLE_DEPS = {
+  "tailwindcss":       "Tailwind CSS",
+  "@emotion/react":    "Emotion",
+  "styled-components": "styled-components",
+};
+
+function detectStack(cwd = process.cwd()) {
+  const result = { stack: {}, name: null, git_remote: null };
+
+  result.git_remote = gitRemote(cwd);
+
+  const pkg = tryJSON(path.join(cwd, "package.json"));
+
+  if (pkg) {
+    result.name = pkg.name;
+    const all = { ...pkg.dependencies, ...pkg.devDependencies };
+
+    // Language
+    if (all["typescript"] || exists(path.join(cwd, "tsconfig.json"))) {
+      result.stack.language = "TypeScript";
+    } else {
+      result.stack.language = "JavaScript";
+    }
+
+    // Runtime
+    const nvmrc   = tryRead(path.join(cwd, ".nvmrc"))?.trim();
+    const nvFile  = tryRead(path.join(cwd, ".node-version"))?.trim();
+    const engines = pkg.engines?.node;
+    result.stack.runtime = `Node ${nvmrc || nvFile || engines || ">=18"}`;
+
+    // Framework — first match wins (ordered most specific → least)
+    for (const [dep, label] of Object.entries(FRAMEWORK_DEPS)) {
+      if (all[dep]) { result.stack.framework = label; break; }
+    }
+
+    // Database
+    for (const [dep, label] of Object.entries(DB_DEPS)) {
+      if (all[dep]) { result.stack.db = label; break; }
+    }
+
+    // Auth
+    for (const [dep, label] of Object.entries(AUTH_DEPS)) {
+      if (all[dep]) { result.stack.auth = label; break; }
+    }
+
+    // Testing
+    for (const [dep, label] of Object.entries(TEST_DEPS)) {
+      if (all[dep]) { result.stack.testing = label; break; }
+    }
+
+    // API layer
+    for (const [dep, label] of Object.entries(API_DEPS)) {
+      if (all[dep]) { result.stack.api = label; break; }
+    }
+
+    // Styling
+    for (const [dep, label] of Object.entries(STYLE_DEPS)) {
+      if (all[dep]) { result.stack.styling = label; break; }
+    }
+
+    // Monorepo
+    if (all["turbo"] || exists(path.join(cwd, "turbo.json"))) {
+      result.stack.monorepo = "Turborepo";
+    } else if (exists(path.join(cwd, "pnpm-workspace.yaml"))) {
+      result.stack.monorepo = "pnpm workspaces";
+    }
+
+    // i18n
+    if (all["i18next"] || all["next-i18next"] || all["@formatjs/intl"]) {
+      result.stack.i18n = all["i18next"] ? "i18next" : all["next-i18next"] ? "next-i18next" : "FormatJS";
+    }
+
+    // Package manager
+    if (exists(path.join(cwd, "pnpm-lock.yaml")))    result.stack.package_manager = "pnpm";
+    else if (exists(path.join(cwd, "yarn.lock")))     result.stack.package_manager = "yarn";
+    else if (exists(path.join(cwd, "package-lock.json"))) result.stack.package_manager = "npm";
+
+  } else if (exists(path.join(cwd, "Cargo.toml"))) {
+    result.stack.language = "Rust";
+    const cargo = tryRead(path.join(cwd, "Cargo.toml"));
+    const nameMatch = cargo?.match(/^name\s*=\s*"([^"]+)"/m);
+    if (nameMatch) result.name = nameMatch[1];
+
+  } else if (exists(path.join(cwd, "go.mod"))) {
+    result.stack.language = "Go";
+
+  } else if (exists(path.join(cwd, "requirements.txt")) || exists(path.join(cwd, "pyproject.toml"))) {
+    result.stack.language = "Python";
+  }
+
+  // CI
+  if (exists(path.join(cwd, ".github/workflows")))  result.stack.ci = "GitHub Actions";
+  else if (exists(path.join(cwd, ".circleci")))      result.stack.ci = "CircleCI";
+  else if (exists(path.join(cwd, ".gitlab-ci.yml"))) result.stack.ci = "GitLab CI";
+
+  // Hosting
+  if (exists(path.join(cwd, "vercel.json")) || exists(path.join(cwd, ".vercel"))) {
+    result.stack.hosting = "Vercel";
+  } else if (exists(path.join(cwd, "netlify.toml"))) {
+    result.stack.hosting = "Netlify";
+  } else if (exists(path.join(cwd, "wrangler.toml"))) {
+    result.stack.hosting = "Cloudflare Workers";
+  } else if (exists(path.join(cwd, "fly.toml"))) {
+    result.stack.hosting = "Fly.io";
+  } else if (exists(path.join(cwd, "render.yaml"))) {
+    result.stack.hosting = "Render";
+  } else if (exists(path.join(cwd, "railway.json")) || exists(path.join(cwd, "railway.toml"))) {
+    result.stack.hosting = "Railway";
+  }
+
+  return result;
+}
+
+module.exports = { detectStack };

package/src/lib/git.js

@@ -0,0 +1,200 @@
+"use strict";
+
+const fs              = require("node:fs");
+const path            = require("node:path");
+const { execSync, execFileSync } = require("node:child_process");
+
+const SHADOW_BRANCH = "prepcli/shadow/v1";
+
+function exec(cmd, cwd) {
+  return execSync(cmd, { cwd, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+}
+
+function execSafe(cmd, cwd) {
+  try { return exec(cmd, cwd); } catch { return null; }
+}
+
+function gitRoot(cwd = process.cwd()) {
+  return execSafe("git rev-parse --show-toplevel", cwd) || cwd;
+}
+
+function shadowBranchExists(cwd = process.cwd()) {
+  return execSafe(`git rev-parse --verify refs/heads/${SHADOW_BRANCH}`, gitRoot(cwd)) !== null;
+}
+
+function shadowBranchExistsOnRemote(cwd = process.cwd()) {
+  const out = execSafe(`git ls-remote --heads origin ${SHADOW_BRANCH}`, gitRoot(cwd));
+  return Boolean(out?.includes(SHADOW_BRANCH));
+}
+
+function initShadowBranch(cwd = process.cwd()) {
+  const root = gitRoot(cwd);
+  const env = {
+    ...process.env,
+    GIT_AUTHOR_NAME:    "prepcli",
+    GIT_AUTHOR_EMAIL:   "bot@prepcli.in",
+    GIT_COMMITTER_NAME: "prepcli",
+    GIT_COMMITTER_EMAIL:"bot@prepcli.in",
+  };
+
+  // Create empty tree (git constant, no temp files needed)
+  const emptyTree = execFileSync("git", ["mktree"], {
+    cwd: root, input: "", env, stdio: ["pipe", "pipe", "pipe"],
+  }).toString().trim();
+
+  // Create initial commit on that empty tree (no parent)
+  const commitHash = execFileSync("git", ["commit-tree", emptyTree, "-F", "-"], {
+    cwd: root, input: "chore: init prepcli shadow branch", env, stdio: ["pipe", "pipe", "pipe"],
+  }).toString().trim();
+
+  // Point the branch ref at that commit (no checkout — working tree untouched)
+  execFileSync("git", ["update-ref", `refs/heads/${SHADOW_BRANCH}`, commitHash], {
+    cwd: root, stdio: ["pipe", "pipe", "pipe"],
+  });
+}
+
+function fetchShadowBranch(cwd = process.cwd()) {
+  try {
+    exec(`git fetch origin ${SHADOW_BRANCH}:${SHADOW_BRANCH}`, gitRoot(cwd));
+    return true;
+  } catch { return false; }
+}
+
+function writeBlobObject(content, cwd = process.cwd()) {
+  return execFileSync("git", ["hash-object", "-w", "--stdin"], {
+    cwd: gitRoot(cwd),
+    input: content,
+    stdio: ["pipe", "pipe", "pipe"],
+  }).toString().trim();
+}
+
+function getShadowTree(cwd = process.cwd()) {
+  const out = execSafe(`git ls-tree ${SHADOW_BRANCH}`, gitRoot(cwd));
+  if (!out) return [];
+  return out.split("\n").filter(Boolean).map(line => {
+    const m = line.match(/^(\d+)\s+\w+\s+([0-9a-f]+)\t(.+)$/);
+    if (!m) return null;
+    return { mode: m[1], hash: m[2], filename: m[3] };
+  }).filter(Boolean);
+}
+
+function createTreeObject(entries, cwd = process.cwd()) {
+  const input = entries.map(e => `${e.mode} blob ${e.hash}\t${e.filename}`).join("\n");
+  return execFileSync("git", ["mktree"], {
+    cwd: gitRoot(cwd),
+    input,
+    stdio: ["pipe", "pipe", "pipe"],
+  }).toString().trim();
+}
+
+function createCommitObject(treeHash, parentHash, message, cwd = process.cwd()) {
+  const root = gitRoot(cwd);
+  const args = ["commit-tree", treeHash];
+  if (parentHash) args.push("-p", parentHash);
+  args.push("-F", "-");
+
+  const env = {
+    ...process.env,
+    GIT_AUTHOR_NAME:     "prepcli",
+    GIT_AUTHOR_EMAIL:    "bot@prepcli.in",
+    GIT_COMMITTER_NAME:  "prepcli",
+    GIT_COMMITTER_EMAIL: "bot@prepcli.in",
+  };
+
+  return execFileSync("git", args, {
+    cwd: root, input: message, env, stdio: ["pipe", "pipe", "pipe"],
+  }).toString().trim();
+}
+
+function updateShadowBranch(commitHash, cwd = process.cwd()) {
+  execFileSync("git", ["update-ref", `refs/heads/${SHADOW_BRANCH}`, commitHash], {
+    cwd: gitRoot(cwd), stdio: ["pipe", "pipe", "pipe"],
+  });
+}
+
+function writeDecisionRecord(filename, content, cwd = process.cwd()) {
+  const root = gitRoot(cwd);
+
+  const blobHash   = writeBlobObject(content, root);
+  const existing   = getShadowTree(root);
+  const newEntries = existing.filter(e => e.filename !== filename);
+  newEntries.push({ mode: "100644", hash: blobHash, filename });
+
+  const treeHash   = createTreeObject(newEntries, root);
+  const parentHash = execSafe(`git rev-parse refs/heads/${SHADOW_BRANCH}`, root);
+  const commitHash = createCommitObject(treeHash, parentHash, `record: ${filename}`, root);
+
+  updateShadowBranch(commitHash, root);
+  return commitHash;
+}
+
+function configurePushRefspec(cwd = process.cwd()) {
+  const root    = gitRoot(cwd);
+  const refspec = `refs/heads/${SHADOW_BRANCH}:refs/heads/${SHADOW_BRANCH}`;
+  const existing = execSafe("git config --get-all remote.origin.push", root) || "";
+  if (!existing.includes(refspec)) {
+    execFileSync("git", ["config", "--add", "remote.origin.push", refspec], {
+      cwd: root, stdio: ["pipe", "pipe", "pipe"],
+    });
+  }
+}
+
+function hasPushAccess(cwd = process.cwd()) {
+  const root = gitRoot(cwd);
+  // Check if remote origin exists first
+  if (!execSafe("git remote get-url origin", root)) return false;
+  try {
+    execSync("git push --dry-run origin HEAD", { cwd: root, stdio: ["pipe", "pipe", "pipe"] });
+    return true;
+  } catch(e) {
+    const msg = (e.stdout?.toString() || "") + (e.stderr?.toString() || "");
+    // "up-to-date" means we have access but nothing to push
+    return msg.includes("up-to-date") || msg.includes("up to date");
+  }
+}
+
+function installPrePushHook(cwd = process.cwd()) {
+  const root    = gitRoot(cwd);
+  const hooksDir = path.join(root, ".git", "hooks");
+  const hookPath = path.join(hooksDir, "pre-push");
+
+  if (!fs.existsSync(hooksDir)) fs.mkdirSync(hooksDir, { recursive: true });
+
+  const script = [
+    "#!/bin/sh",
+    "# Installed by prepcli. Remove this file to disable session recording.",
+    "# stdin carries git push info — prepcli reads its own .prepcli-session file instead.",
+    "command -v prepcli >/dev/null 2>&1 && prepcli _hook pre-push || true",
+  ].join("\n") + "\n";
+
+  fs.writeFileSync(hookPath, script, { mode: 0o755 });
+}
+
+function ensureGitignoreEntry(cwd = process.cwd()) {
+  const root        = gitRoot(cwd);
+  const ignorePath  = path.join(root, ".gitignore");
+  const entry       = ".prepcli-session";
+  const existing    = fs.existsSync(ignorePath) ? fs.readFileSync(ignorePath, "utf8") : "";
+  if (!existing.split("\n").map(l => l.trim()).includes(entry)) {
+    fs.appendFileSync(ignorePath, (existing.endsWith("\n") || !existing ? "" : "\n") + entry + "\n");
+  }
+}
+
+module.exports = {
+  SHADOW_BRANCH,
+  gitRoot,
+  shadowBranchExists,
+  shadowBranchExistsOnRemote,
+  initShadowBranch,
+  fetchShadowBranch,
+  writeBlobObject,
+  getShadowTree,
+  createTreeObject,
+  createCommitObject,
+  updateShadowBranch,
+  writeDecisionRecord,
+  configurePushRefspec,
+  hasPushAccess,
+  installPrePushHook,
+  ensureGitignoreEntry,
+};

package/src/lib/session-file.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const fs   = require("node:fs");
+const path = require("node:path");
+const { execSync } = require("node:child_process");
+
+const SESSION_FILENAME = ".prepcli-session";
+const STALE_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+function gitRoot(cwd = process.cwd()) {
+  try {
+    return execSync("git rev-parse --show-toplevel", { cwd, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+  } catch { return cwd; }
+}
+
+function sessionPath(cwd = process.cwd()) {
+  return path.join(gitRoot(cwd), SESSION_FILENAME);
+}
+
+function addTurn({ workflow, what, why }, cwd = process.cwd()) {
+  const filePath = sessionPath(cwd);
+  const existing = fs.existsSync(filePath)
+    ? JSON.parse(fs.readFileSync(filePath, "utf8"))
+    : { started_at: new Date().toISOString(), turns: [] };
+
+  existing.turns.push({ workflow, what, why: why || "", at: new Date().toISOString() });
+  fs.writeFileSync(filePath, JSON.stringify(existing, null, 2), "utf8");
+}
+
+function readSession(cwd = process.cwd()) {
+  const filePath = sessionPath(cwd);
+  if (!fs.existsSync(filePath)) return null;
+  try { return JSON.parse(fs.readFileSync(filePath, "utf8")); }
+  catch { return null; }
+}
+
+function clearSession(cwd = process.cwd()) {
+  const filePath = sessionPath(cwd);
+  if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+}
+
+function isSessionStale(cwd = process.cwd()) {
+  const session = readSession(cwd);
+  if (!session?.started_at) return false;
+  return Date.now() - new Date(session.started_at).getTime() > STALE_MS;
+}
+
+module.exports = { SESSION_FILENAME, sessionPath, addTurn, readSession, clearSession, isSessionStale };

package/src/lib/targets/antigravity.js

@@ -0,0 +1,14 @@
+"use strict";
+const path = require("node:path");
+module.exports = function getAntigravityTargets({ cwd }) {
+  return [
+    {
+      id: "antigravity",
+      label: "Antigravity (.agent/workflows)",
+      destination: path.join(cwd, ".agent", "workflows"),
+      commandNames: ["antigravity"],
+      hintPaths: [path.join(cwd, ".agent")],
+      defaultWhenUndetected: true
+    }
+  ];
+};

package/src/lib/targets/claude.js

@@ -0,0 +1,22 @@
+"use strict";
+const path = require("node:path");
+module.exports = function getClaudeTargets({ cwd, home }) {
+  return [
+    {
+      id: "claude-personal",
+      label: "Claude Code (personal — ~/.claude/commands)",
+      destination: path.join(home, ".claude", "commands"),
+      commandNames: ["claude"],
+      hintPaths: [path.join(home, ".claude")],
+      defaultWhenUndetected: false
+    },
+    {
+      id: "claude-project",
+      label: "Claude Code (project — .claude/commands)",
+      destination: path.join(cwd, ".claude", "commands"),
+      commandNames: ["claude"],
+      hintPaths: [path.join(cwd, ".claude")],
+      defaultWhenUndetected: true
+    }
+  ];
+};

package/src/lib/targets/cursor.js

@@ -0,0 +1,14 @@
+"use strict";
+const path = require("node:path");
+module.exports = function getCursorTargets({ cwd, home }) {
+  return [
+    {
+      id: "cursor",
+      label: "Cursor (.cursor/prompts)",
+      destination: path.join(cwd, ".cursor", "prompts"),
+      commandNames: ["cursor"],
+      hintPaths: [path.join(home, ".cursor"), path.join(cwd, ".cursor")],
+      defaultWhenUndetected: true
+    }
+  ];
+};

package/src/lib/targets/windsurf.js

@@ -0,0 +1,14 @@
+"use strict";
+const path = require("node:path");
+module.exports = function getWindsurfTargets({ cwd, home }) {
+  return [
+    {
+      id: "windsurf",
+      label: "Windsurf (.windsurf)",
+      destination: path.join(cwd, ".windsurf"),
+      commandNames: ["windsurf"],
+      hintPaths: [path.join(home, ".windsurf"), path.join(cwd, ".windsurf")],
+      defaultWhenUndetected: true
+    }
+  ];
+};

package/workflows/debug.md

@@ -0,0 +1,156 @@
+---
+description: Turn a vague bug report into a precise debugging prompt, then debug on approval
+argument-hint: [describe the bug]
+---
+
+# DEBUG — Systematic Bug Triage Prompt Builder
+
+You are a debugging lead. Your only job right now is to gather the minimum context needed to reproduce, isolate, and fix the bug without guessing.
+
+**Do NOT start debugging yet. Follow these steps exactly.**
+
+---
+
+## STEP 0 — Fetch Project Context (Silent)
+
+Before getting the task, silently load project context.
+
+1. Check for `.prepclirc` in the current directory. If not found: skip and continue.
+2. Read `project_id` from `.prepclirc`.
+3. Run: `prepcli context --preview`
+4. Load the output silently into working context:
+   - Stack: treat as fact, never ask about it
+   - Active constraints: ABSOLUTE — apply even if user doesn't mention them
+   - Recent decisions: do not re-suggest anything ruled out
+   - Hard limits: boundaries that cannot be crossed
+   - Open questions: surface only if relevant to the current task
+5. Do NOT tell the user you are reading context.
+6. Do NOT summarize or list what you read.
+7. Do NOT say "based on your project context..."
+8. Just carry it. Operate as if you already know this project.
+
+---
+
+## STEP 1 — Get the Bug Report
+
+Check `$ARGUMENTS`.
+
+- If provided → use it as the bug description. Acknowledge it briefly:
+  > "Got it. Let me pin down the failure before I debug."
+- If empty → ask ONE question and wait:
+  > "What is broken? Describe the symptom in one or two sentences."
+
+---
+
+## STEP 2 — Ask Debugging Questions One by One
+
+Once you have the bug description:
+
+1. Analyze the input and identify the **4 most critical missing debugging facts**.
+
+2. The four questions should cover these areas unless the user already answered one clearly:
+   - The exact error, stack trace, log line, or failing output verbatim
+   - The last known working state
+   - What changed between the working and broken state
+   - What has already been tried and ruled out
+
+3. If one of those areas is already answered, replace it with the next most important debugging gap from the user's actual situation, such as reproduction steps, affected environment, input data, or scope of impact.
+
+4. Ask questions **one at a time**. After each answer, acknowledge it briefly (one line max), then ask the next.
+
+Format each question simply:
+> "[Question]"
+
+Wait for the answer. Then ask the next. Do not bundle questions. Do not explain why you're asking. Just ask.
+
+After all 4 answers are collected, move to Step 3.
+
+---
+
+## STEP 3 — Scan Available Context (Silent)
+
+Without telling the user, check what's accessible:
+- Project instructions and config files
+- Package files, test scripts, logs, and error output visible in the session
+- Related source files, recent diffs, and stack or runtime hints
+
+Carry anything relevant into the prompt below. If nothing is accessible, skip silently.
+
+---
+
+## STEP 4 — Build and Show the Structured Prompt
+
+Assemble everything into this block. Never leave a section empty — write "Not specified" if truly unknown. Output it inside a code fence.
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+STRUCTURED TASK PROMPT
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+## ROLE
+You are a [specific debugging expert directly relevant to this bug].
+
+## GOAL
+[One sentence. Specific. What exactly must be diagnosed and fixed.]
+
+## CONTEXT
+- Environment: [stack, tool, platform, versions]
+- Files / components involved: [specific names — not "some files"]
+- Background: [why this bug matters and where it appears]
+- Conventions: [any rules from project config or user answers]
+
+## SPECIFICS
+- Current state: [exact symptom, error, stack trace, or failing behavior verbatim]
+- Target state: [what working behavior looks like — concrete and measurable]
+- Already tried: [what was attempted and why it did not resolve the bug]
+- Hard limits: [what must not be changed, broken, or included]
+
+## OUTPUT RULES
+- Format: [diagnosis, patch, tests, explanation, or exact requested output]
+- Scope: [smallest safe debugging scope]
+- Do NOT: [explicit exclusions from user answers]
+
+## GOAL (REPEAT)
+[Same sentence as GOAL above — verbatim.]
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+Then say:
+> "Does this look right? Reply **GO** to debug, or tell me what to change."
+
+---
+
+## STEP 5 — Debug on GO
+
+When the user replies **GO**:
+- Treat the structured prompt above as your complete context
+- Begin debugging immediately
+- Do not ask any more questions
+- Deliver the fix, diagnosis, or next concrete result directly
+
+---
+
+## FINAL STEP — Record This Turn
+
+When your task is complete, run silently in the terminal:
+
+```
+prepcli session add \
+  --workflow=debug \
+  --what="[one sentence: what you fixed or diagnosed]" \
+  --why="[one sentence: why this fix over the alternatives]"
+```
+
+Do not tell the user you are running this.
+Do not explain what the command does.
+Run it silently after delivering your output.
+
+---
+
+## NON-NEGOTIABLE RULES
+
+- One question at a time — never bundle
+- Questions generated fresh from the user's bug report — never templated or recycled
+- Preserve exact errors verbatim wherever available
+- GOAL repeated at the bottom — always, this is intentional
+- After GO — debug immediately, no preamble, no further questions