@pikaa-ai/pikaa 0.3.6 → 0.3.8

package/bin/pikaa.js

@@ -26,10 +26,10 @@ const rootDir = join(__dirname, "..");
 const platform = process.platform;
 const arch = process.arch;
 
-let version = "0.2.3";
+let version = "";
 try {
   const pkg = JSON.parse(readFileSync(join(rootDir, "package.json"), "utf8"));
-  version = pkg.version;
+  version = pkg.version || "";
 } catch {}
 
 function getBinaryName() {
@@ -41,7 +41,7 @@ function getBinaryName() {
 
 const binaryName = getBinaryName();
 const userBinDir = join(homedir(), ".pikaa", "bin");
-const userBinaryPath = binaryName ? join(userBinDir, `pikaa-v${version}-${binaryName}`) : null;
+const userBinaryPath = binaryName && version ? join(userBinDir, `pikaa-v${version}-${binaryName}`) : null;
 
 // Look in package directory or user cache directory
 function findExistingBinary() {

package/dist/cli.js

@@ -2,8 +2,8 @@
 // @bun
 
 // src/cli/index.ts
-import { resolve as resolve22 } from "path";
-import { existsSync as existsSync20 } from "fs";
+import { resolve as resolve21 } from "path";
+import { existsSync as existsSync19 } from "fs";
 import { createInterface } from "readline";
 
 // src/auth/store.ts
@@ -975,6 +975,7 @@ async function runTurn(session, turnContext, input) {
             signal,
             execPolicy: session.execPolicy,
             mode: session.collaborationMode,
+            permissionMode: session.permissionMode,
             onPlanUpdate: (plan, explanation) => {
               session.emitEvent({
                 type: "PlanUpdated",
@@ -1125,9 +1126,17 @@ async function submissionLoop(session, queue) {
 // src/security/exec-policy.ts
 class ExecPolicy {
   rules = [];
-  constructor() {
+  mode = "auto";
+  constructor(initialMode = "auto") {
+    this.mode = initialMode;
     this.initDefaultRules();
   }
+  getMode() {
+    return this.mode;
+  }
+  setMode(mode) {
+    this.mode = mode;
+  }
   initDefaultRules() {
     this.addRule(/^(git\s+(status|log|diff|branch|show|rev-parse))/i, "allow", "Safe git query");
     this.addRule(/^(ls|dir|cat|type|grep|rg|find|pwd|echo|head|tail|wc|which|where)\b/i, "allow", "Safe read-only shell command");
@@ -1139,8 +1148,47 @@ class ExecPolicy {
   addRule(pattern, decision, description) {
     this.rules.unshift({ pattern, decision, description });
   }
+  shouldPromptFileEdit(filePath) {
+    if (this.mode === "plan") {
+      return {
+        prompt: false,
+        isPlanBlocked: true,
+        reason: "Plan Mode is active. Mutating files is not allowed while planning."
+      };
+    }
+    if (this.mode === "manual") {
+      return {
+        prompt: true,
+        reason: `Manual mode requires approval to modify '${filePath || "file"}'`
+      };
+    }
+    return { prompt: false };
+  }
   evaluate(command) {
     const trimmed = command.trim();
+    if (this.mode === "plan") {
+      const isReadOnly = /^(git\s+(status|log|diff|branch|show)|ls|dir|cat|type|grep|rg|find|pwd|which|where)\b/i.test(trimmed);
+      if (isReadOnly) {
+        return { decision: "allow", reason: "Read-only inspection allowed in Plan mode" };
+      }
+      return { decision: "deny", reason: "Cannot execute mutating shell commands in Plan mode" };
+    }
+    if (this.mode === "manual") {
+      return {
+        decision: "prompt",
+        reason: "Manual mode requires confirmation for all shell commands"
+      };
+    }
+    if (this.mode === "accept-edits") {
+      const isReadOnly = /^(git\s+(status|log|diff|branch|show)|ls|dir|cat|type|grep|rg|find|pwd|bun\s+test|npm\s+test)\b/i.test(trimmed);
+      if (isReadOnly) {
+        return { decision: "allow", reason: "Safe read-only command in accept-edits mode" };
+      }
+      return {
+        decision: "prompt",
+        reason: "Accept-edits mode requires approval for active shell commands"
+      };
+    }
     for (const rule of this.rules) {
       if (rule.pattern.test(trimmed)) {
         return {
@@ -1150,8 +1198,8 @@ class ExecPolicy {
       }
     }
     return {
-      decision: "prompt",
-      reason: "Command is not in the automatic allowlist"
+      decision: "allow",
+      reason: "Auto mode allows execution"
     };
   }
 }
@@ -1169,6 +1217,17 @@ class Session {
   mcpManager;
   execPolicy;
   collaborationMode = "default";
+  get permissionMode() {
+    return this.execPolicy.getMode();
+  }
+  setPermissionMode(mode) {
+    this.execPolicy.setMode(mode);
+    if (mode === "plan") {
+      this.collaborationMode = "plan";
+    } else if (this.collaborationMode === "plan") {
+      this.collaborationMode = "default";
+    }
+  }
   history = [];
   activeTurn = null;
   status = "idle";
@@ -1415,6 +1474,22 @@ var applyPatchTool = {
     const filePath = resolve4(ctx.cwd, rawPath);
     const targetContent = typeof args.targetContent === "string" ? args.targetContent : "";
     const replacementContent = String(args.replacementContent ?? "");
+    if (ctx.execPolicy) {
+      const evalResult = ctx.execPolicy.shouldPromptFileEdit(rawPath);
+      if (evalResult.isPlanBlocked || ctx.mode === "plan") {
+        return {
+          output: "Error: Cannot mutate files while in Plan Mode. Please present the implementation plan first.",
+          isError: true
+        };
+      }
+      if (evalResult.prompt && ctx.requestApproval) {
+        const approval = await ctx.requestApproval(`Apply patch to: ${rawPath}`, `apply_patch ${rawPath}`);
+        const allowed = typeof approval === "object" ? approval.allowed : Boolean(approval);
+        if (!allowed) {
+          return { output: `Action rejected by user: apply_patch '${rawPath}'`, isError: true };
+        }
+      }
+    }
     if (!existsSync4(filePath)) {
       if (targetContent) {
         return {
@@ -2049,7 +2124,24 @@ var writeFileTool = {
     required: ["path", "content"]
   },
   async execute(args, ctx) {
-    const filePath = resolve7(ctx.cwd, String(args.path || ""));
+    const rawPath = String(args.path || "");
+    const filePath = resolve7(ctx.cwd, rawPath);
+    if (ctx.execPolicy) {
+      const evalResult = ctx.execPolicy.shouldPromptFileEdit(rawPath);
+      if (evalResult.isPlanBlocked || ctx.mode === "plan") {
+        return {
+          output: "Error: Cannot write or mutate files while in Plan Mode. Please present the implementation plan first.",
+          isError: true
+        };
+      }
+      if (evalResult.prompt && ctx.requestApproval) {
+        const approval = await ctx.requestApproval(`Write file: ${rawPath}`, `write_file ${rawPath}`);
+        const allowed = typeof approval === "object" ? approval.allowed : Boolean(approval);
+        if (!allowed) {
+          return { output: `Action rejected by user: write_file '${rawPath}'`, isError: true };
+        }
+      }
+    }
     try {
       mkdirSync4(dirname4(filePath), { recursive: true });
       writeFileSync3(filePath, String(args.content ?? ""), "utf8");
@@ -5938,12 +6030,63 @@ function parsePatch(oldSrc, newSrc, contextLines = 3) {
   }
   return result;
 }
+// package.json
+var package_default = {
+  name: "@pikaa-ai/pikaa",
+  version: "0.3.8",
+  description: "PIKAA CLI - AI coding agent that runs locally in your terminal.",
+  main: "./dist/index.js",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  bin: {
+    pikaa: "./bin/pikaa.js",
+    groupy: "./bin/pikaa.js"
+  },
+  type: "module",
+  files: [
+    "dist/index.js",
+    "dist/cli.js",
+    "bin",
+    "templates",
+    "assets",
+    "skills/**/SKILL.md",
+    "README.md",
+    "LICENSE"
+  ],
+  scripts: {
+    start: "bun run src/cli/index.ts",
+    test: "bun test --timeout 30000",
+    typecheck: "tsc --noEmit",
+    "build:js": "bun build ./src/index.ts --outdir ./dist --target=bun && bun build ./src/cli/index.ts --outfile ./dist/cli.js --target=bun",
+    "build:exe": "bun build ./src/cli/index.ts --compile --outfile pikaa.exe",
+    "build:binaries": "bun run scripts/build-binaries.ts",
+    "release:prepare": "bun run scripts/prepare-release.ts",
+    build: "bun run build:js && bun run build:exe",
+    prepublishOnly: "bun run build:js"
+  },
+  keywords: [
+    "ai",
+    "coding-agent",
+    "codex",
+    "claude-code",
+    "cli",
+    "agentic",
+    "sub-agents",
+    "mcp",
+    "worktree"
+  ],
+  author: "Mesosfer",
+  license: "MIT",
+  devDependencies: {
+    "@types/bun": "latest",
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.2.18",
+    react: "^19.2.8",
+    typescript: "^5.7.0"
+  }
+};
 
 // src/cli/version.ts
-import { existsSync as existsSync17, readFileSync as readFileSync12 } from "fs";
-import { dirname as dirname8, join as join8, resolve as resolve17 } from "path";
-import { fileURLToPath } from "url";
-var __dirname = "/home/runner/work/agent-cli/agent-cli/src/cli";
 var cachedMetadata = null;
 function getPackageMetadata() {
   if (cachedMetadata) {
@@ -5951,59 +6094,13 @@ function getPackageMetadata() {
   }
   const envVersion = process.env.PIKAA_VERSION || process.env.GROUPY_VERSION;
   const envName = process.env.PIKAA_NAME || process.env.GROUPY_NAME;
-  if (envVersion) {
-    cachedMetadata = {
-      name: envName || "pikaa",
-      version: envVersion
-    };
-    return cachedMetadata;
-  }
-  const searchDirs = [];
-  try {
-    const currentDir = typeof __dirname !== "undefined" ? __dirname : dirname8(fileURLToPath(import.meta.url));
-    searchDirs.push(currentDir);
-  } catch {}
-  for (const startDir of searchDirs) {
-    let current = resolve17(startDir);
-    for (let depth = 0;depth < 5; depth++) {
-      const candidate = join8(current, "package.json");
-      if (existsSync17(candidate)) {
-        try {
-          const content = JSON.parse(readFileSync12(candidate, "utf8"));
-          if (content && typeof content.version === "string" && (content.name === "@pikaa-ai/pikaa" || content.name === "pikaa" || content.bin?.pikaa || content.bin?.groupy)) {
-            const cleanName = content.name?.startsWith("@") ? content.name.split("/")[1] || content.name : content.name || "pikaa";
-            cachedMetadata = {
-              name: cleanName,
-              version: content.version,
-              description: content.description
-            };
-            return cachedMetadata;
-          }
-        } catch {}
-      }
-      const parent = dirname8(current);
-      if (parent === current)
-        break;
-      current = parent;
-    }
-  }
-  try {
-    const cwdCandidate = join8(process.cwd(), "package.json");
-    if (existsSync17(cwdCandidate)) {
-      const content = JSON.parse(readFileSync12(cwdCandidate, "utf8"));
-      if (content && typeof content.version === "string" && (content.name === "@pikaa-ai/pikaa" || content.name === "pikaa" || content.bin?.pikaa || content.bin?.groupy)) {
-        cachedMetadata = {
-          name: "pikaa",
-          version: content.version,
-          description: content.description
-        };
-        return cachedMetadata;
-      }
-    }
-  } catch {}
+  const rawName = package_default?.name || "pikaa";
+  const cleanName = rawName.startsWith("@") ? rawName.split("/")[1] || rawName : rawName;
+  const autoVersion = package_default && typeof package_default.version === "string" ? package_default.version : "0.0.0";
   cachedMetadata = {
-    name: "pikaa",
-    version: "0.3.5"
+    name: envName || cleanName,
+    version: envVersion || autoVersion,
+    description: package_default?.description
   };
   return cachedMetadata;
 }
@@ -6445,10 +6542,41 @@ ${preview}${more}`);
     console.log();
   }
   static formatClaudeUserPrompt(text) {
-    const cols = typeof process.stdout?.columns === "number" ? process.stdout.columns : 80;
-    const width = Math.min(76, Math.max(48, cols - 6));
-    const pad = Math.max(1, width - (text.length + 5));
-    return `  \x1B[48;2;50;50;52m\x1B[38;2;145;145;150m \u276F \x1B[38;2;255;255;255m\x1B[1m${text}${" ".repeat(pad)}\x1B[0m`;
+    const cols = typeof process.stdout?.columns === "number" && process.stdout.columns > 0 ? process.stdout.columns : 80;
+    const boxWidth = Math.max(20, cols - 2);
+    const contentWidth = Math.max(10, boxWidth - 3);
+    const BG = "\x1B[48;2;43;43;45m";
+    const CHEVRON = "\x1B[38;2;128;128;133m";
+    const TEXT = "\x1B[38;2;240;240;242m";
+    const RESET2 = "\x1B[0m";
+    const rawLines = text.split(`
+`);
+    const wrappedLines = [];
+    for (const rawLine of rawLines) {
+      if (rawLine.length === 0) {
+        wrappedLines.push("");
+        continue;
+      }
+      let current = rawLine;
+      while (current.length > contentWidth) {
+        let breakIdx = current.lastIndexOf(" ", contentWidth);
+        if (breakIdx <= 0) {
+          breakIdx = contentWidth;
+        }
+        wrappedLines.push(current.slice(0, breakIdx));
+        current = current.slice(breakIdx).trimStart();
+      }
+      if (current.length > 0) {
+        wrappedLines.push(current);
+      }
+    }
+    const formatted = wrappedLines.map((line, idx) => {
+      const prefix = idx === 0 ? `${CHEVRON} \u276F ` : `${CHEVRON}   `;
+      const padLen = Math.max(0, contentWidth - line.length);
+      return `  ${BG}${prefix}${TEXT}${line}${" ".repeat(padLen)}${RESET2}`;
+    });
+    return formatted.join(`
+`);
   }
   static formatClaudeAssistantResponse(text) {
     return `  \x1B[38;2;192;202;245m${text}\x1B[0m`;
@@ -6481,25 +6609,62 @@ function ensureKeypressInitialized() {
 class InteractiveLineEditor {
   promptSymbol;
   cwd;
+  mode;
   onInterrupt;
+  onModeChange;
   searchEngine = new FileSearchEngine;
   constructor(options = {}) {
     this.promptSymbol = options.promptSymbol || "  \x1B[38;2;192;202;245m\u276F\x1B[0m ";
     this.cwd = options.cwd || process.cwd();
+    this.mode = options.initialMode || "auto";
     this.onInterrupt = options.onInterrupt;
+    this.onModeChange = options.onModeChange;
+  }
+  getMode() {
+    return this.mode;
+  }
+  setMode(mode) {
+    this.mode = mode;
+    this.onModeChange?.(mode);
+  }
+  cycleMode() {
+    const modes = ["auto", "manual", "accept-edits", "plan"];
+    const nextIdx = (modes.indexOf(this.mode) + 1) % modes.length;
+    const next = modes[nextIdx];
+    this.setMode(next);
+    return next;
+  }
+  cycleModeReverse() {
+    const modes = ["auto", "manual", "accept-edits", "plan"];
+    const nextIdx = (modes.indexOf(this.mode) - 1 + modes.length) % modes.length;
+    const next = modes[nextIdx];
+    this.setMode(next);
+    return next;
+  }
+  getModeLine() {
+    switch (this.mode) {
+      case "auto":
+        return `  \x1B[38;2;255;215;0m\u23F5\u23F5 auto mode on\x1B[0m \x1B[38;2;148;148;148m(shift+tab to cycle) \xB7 \u21E0 for agents\x1B[0m`;
+      case "manual":
+        return `  \x1B[38;2;148;148;148m\u23F8 manual mode on \xB7 ? for shortcuts \xB7 \u21E0 for agents\x1B[0m`;
+      case "accept-edits":
+        return `  \x1B[38;2;175;175;215m\u23F5\u23F5 accept edits on\x1B[0m \x1B[38;2;148;148;148m(shift+tab to cycle) \xB7 \u21E0 for agents\x1B[0m`;
+      case "plan":
+        return `  \x1B[38;2;95;175;175m\u23F8 plan mode on\x1B[0m \x1B[38;2;148;148;148m(shift+tab to cycle) \xB7 \u21E0 for agents\x1B[0m`;
+    }
   }
   async readLine() {
     if (!process.stdin.isTTY) {
-      return new Promise((resolve18) => {
+      return new Promise((resolve17) => {
         const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
         rl.question(this.promptSymbol, (answer) => {
           rl.close();
-          resolve18(answer);
+          resolve17(answer);
         });
       });
     }
     ensureKeypressInitialized();
-    return new Promise((resolve18) => {
+    return new Promise((resolve17) => {
       let buffer = "";
       let cursor = 0;
       let selectedIndex = 0;
@@ -6540,6 +6705,14 @@ class InteractiveLineEditor {
           return [];
         }
       };
+      const getTerminalCols = () => {
+        return typeof process.stdout?.columns === "number" && process.stdout.columns > 0 ? process.stdout.columns : 80;
+      };
+      const getRule = () => {
+        const cols = getTerminalCols();
+        const ruleLen = Math.max(10, cols - 4);
+        return "\u2500".repeat(ruleLen);
+      };
       const ensureVisible = (totalItems, visibleRows) => {
         if (totalItems === 0 || visibleRows === 0) {
           scrollTop = 0;
@@ -6567,37 +6740,39 @@ class InteractiveLineEditor {
         }
       };
       const redraw = () => {
-        clearMenu();
+        process.stdout.write("\x1B[J");
         process.stdout.write(`\r\x1B[2K${this.promptSymbol}${buffer}`);
         const slashMatches = getMatchingCommands();
         const activeFile = getActiveFileQuery();
         const fileMatches = activeFile ? getMatchingFiles(activeFile.query) : [];
         if (buffer.startsWith("/") && !popupDismissed && slashMatches.length > 0) {
-          const BOX_WIDTH = 70;
+          const termCols = getTerminalCols();
+          const BOX_WIDTH = Math.max(20, Math.min(termCols - 4, 120));
           const maxVisible = Math.min(slashMatches.length, 7);
           ensureVisible(slashMatches.length, maxVisible);
           const visibleMatches = slashMatches.slice(scrollTop, scrollTop + maxVisible);
           const menuLines = [];
-          const rule = "\u2500".repeat(Math.min(BOX_WIDTH, 68));
-          const RULE_COLOR = "\x1B[38;2;80;80;88m";
+          const rule = "\u2500".repeat(BOX_WIDTH);
+          const RULE_COLOR2 = "\x1B[38;2;80;80;88m";
           const ACTIVE_COLOR = "\x1B[38;2;225;225;225m";
           const INACTIVE_COLOR = "\x1B[38;2;139;139;144m";
           const RESET2 = "\x1B[0m";
-          menuLines.push(`  ${RULE_COLOR}${rule}${RESET2}`);
+          menuLines.push(`  ${RULE_COLOR2}${rule}${RESET2}`);
+          const maxDescLen = Math.max(10, BOX_WIDTH - 22);
           for (let i = 0;i < visibleMatches.length; i++) {
             const cmd = visibleMatches[i];
             const actualIdx = scrollTop + i;
             const isSelected = actualIdx === selectedIndex;
             const marker = isSelected ? `${ACTIVE_COLOR}\u276F${RESET2}` : " ";
             const rawName = cmd.name.padEnd(16).slice(0, 16);
-            const rawDesc = cmd.description.length > 48 ? cmd.description.slice(0, 45) + "..." : cmd.description;
+            const rawDesc = cmd.description.length > maxDescLen ? cmd.description.slice(0, maxDescLen - 3) + "..." : cmd.description;
             if (isSelected) {
               menuLines.push(`  ${marker} \x1B[1m${ACTIVE_COLOR}${rawName}${RESET2}  \x1B[1m${ACTIVE_COLOR}${rawDesc}${RESET2}`);
             } else {
               menuLines.push(`  ${marker} ${INACTIVE_COLOR}${rawName}${RESET2}  ${INACTIVE_COLOR}${rawDesc}${RESET2}`);
             }
           }
-          menuLines.push(`  ${RULE_COLOR}${rule}${RESET2}`);
+          menuLines.push(`  ${RULE_COLOR2}${rule}${RESET2}`);
           for (const line of menuLines) {
             process.stdout.write(`
 \x1B[2K${line}`);
@@ -6605,18 +6780,20 @@ class InteractiveLineEditor {
           renderedMenuLines = menuLines.length;
           process.stdout.write(`\x1B[${renderedMenuLines}A`);
         } else if (activeFile && !popupDismissed && fileMatches.length > 0) {
-          const BOX_WIDTH = 70;
+          const termCols = getTerminalCols();
+          const BOX_WIDTH = Math.max(20, Math.min(termCols - 4, 120));
           const maxVisible = Math.min(fileMatches.length, 7);
           ensureVisible(fileMatches.length, maxVisible);
           const visibleMatches = fileMatches.slice(scrollTop, scrollTop + maxVisible);
           const menuLines = [];
           menuLines.push(`  ${style.dim("\u250C\u2500\u2500")} ${style.brandBold("Files")} ${style.dim("\u2500".repeat(Math.max(10, BOX_WIDTH - 9)) + "\u2510")}`);
+          const maxPathLen = Math.max(10, BOX_WIDTH - 8);
           for (let i = 0;i < visibleMatches.length; i++) {
             const filePath = visibleMatches[i];
             const actualIdx = scrollTop + i;
             const isSelected = actualIdx === selectedIndex;
             const marker = isSelected ? style.brand("\u276F") : " ";
-            const rawPath = filePath.length > 62 ? "..." + filePath.slice(filePath.length - 59) : filePath.padEnd(62);
+            const rawPath = filePath.length > maxPathLen ? "..." + filePath.slice(filePath.length - (maxPathLen - 3)) : filePath.padEnd(maxPathLen);
             const coloredPath = isSelected ? style.brandBold(rawPath) : style.cyan(rawPath);
             menuLines.push(`  ${style.dim("\u2502")} ${marker} ${coloredPath} ${style.dim("\u2502")}`);
           }
@@ -6641,6 +6818,15 @@ class InteractiveLineEditor {
           }
           renderedMenuLines = menuLines.length;
           process.stdout.write(`\x1B[${renderedMenuLines}A`);
+        } else {
+          const RULE_COLOR2 = "\x1B[38;2;60;60;68m";
+          const bottomRule = `  ${RULE_COLOR2}${getRule()}\x1B[0m`;
+          const modeLine = this.getModeLine();
+          process.stdout.write(`
+\x1B[2K${bottomRule}
+\x1B[2K${modeLine}`);
+          renderedMenuLines = 2;
+          process.stdout.write(`\x1B[2A`);
         }
         const visiblePromptLength = this.promptSymbol.replace(/\x1b\[[0-9;]*m/g, "").length;
         const cursorCol = visiblePromptLength + cursor;
@@ -6650,7 +6836,16 @@ class InteractiveLineEditor {
           process.stdout.write("\r");
         }
       };
+      const onResize = () => {
+        redraw();
+      };
+      if (process.stdout && typeof process.stdout.on === "function") {
+        process.stdout.on("resize", onResize);
+      }
       const cleanupAndResolve = (result) => {
+        if (process.stdout && typeof process.stdout.removeListener === "function") {
+          process.stdout.removeListener("resize", onResize);
+        }
         clearMenu();
         process.stdin.removeListener("keypress", onKeypress);
         if (process.stdin.isTTY) {
@@ -6659,14 +6854,14 @@ class InteractiveLineEditor {
           } catch {}
         }
         if (result.trim().length > 0 && !result.startsWith("/")) {
-          process.stdout.write(`\r\x1B[2K${CliFormatter.formatClaudeUserPrompt(result)}
+          process.stdout.write(`\x1B[1A\r\x1B[2K${CliFormatter.formatClaudeUserPrompt(result)}
 
 `);
         } else {
-          process.stdout.write(`
+          process.stdout.write(`\x1B[1A\r\x1B[2K
 `);
         }
-        resolve18(result);
+        resolve17(result);
       };
       const onKeypress = (_str, key) => {
         if (!key)
@@ -6681,6 +6876,9 @@ class InteractiveLineEditor {
             redraw();
             return;
           }
+          if (process.stdout && typeof process.stdout.removeListener === "function") {
+            process.stdout.removeListener("resize", onResize);
+          }
           clearMenu();
           if (process.stdin.isTTY) {
             try {
@@ -6731,6 +6929,12 @@ class InteractiveLineEditor {
           cleanupAndResolve(buffer);
           return;
         }
+        const isShiftTab = key.name === "tab" && Boolean(key.shift) || key.name === "backtab" || key.sequence === "\x1B[Z" || _str === "\x1B[Z";
+        if (isShiftTab) {
+          this.cycleMode();
+          redraw();
+          return;
+        }
         if (key.name === "tab") {
           if (activeFile && !popupDismissed && fileMatches.length > 0) {
             const chosen = fileMatches[selectedIndex] || fileMatches[0];
@@ -6753,8 +6957,14 @@ class InteractiveLineEditor {
               scrollTop = 0;
               popupDismissed = false;
               redraw();
+              return;
             }
           }
+          if (buffer.trim().length === 0) {
+            this.cycleMode();
+            redraw();
+            return;
+          }
           return;
         }
         if (key.name === "up") {
@@ -6818,7 +7028,11 @@ class InteractiveLineEditor {
         }
       };
       process.stdin.on("keypress", onKeypress);
-      process.stdout.write(this.promptSymbol);
+      const RULE_COLOR = "\x1B[38;2;60;60;68m";
+      process.stdout.write(`
+  ${RULE_COLOR}${getRule()}\x1B[0m
+`);
+      redraw();
     });
   }
 }
@@ -6831,7 +7045,7 @@ async function promptChoice(config) {
     if (!process.stdin.readable) {
       return choices[defaultIndex]?.value ?? choices[0].value;
     }
-    return new Promise((resolve18) => {
+    return new Promise((resolve17) => {
       const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
       const hint = choices.map((c3) => c3.isDefault ? `[${c3.key.toUpperCase()}]` : `[${c3.key}]`).join("/");
       let resolved = false;
@@ -6839,7 +7053,7 @@ async function promptChoice(config) {
         if (!resolved) {
           resolved = true;
           rl.close();
-          resolve18(val);
+          resolve17(val);
         }
       };
       rl.question(`${message} ${hint}: `, (answer) => {
@@ -6852,7 +7066,7 @@ async function promptChoice(config) {
       });
     });
   }
-  return new Promise((resolve18) => {
+  return new Promise((resolve17) => {
     let selectedIndex = defaultIndex;
     if (selectedIndex < 0 || selectedIndex >= choices.length)
       selectedIndex = 0;
@@ -6881,7 +7095,7 @@ async function promptChoice(config) {
       } catch {}
       process.stdout.write(`\r\x1B[1A\r\x1B[2K  ${style.bold(message)} ${style.cyan(`[${confirmedChoice.key}] ${confirmedChoice.label}`)}
 \r\x1B[2K`);
-      resolve18(confirmedChoice.value);
+      resolve17(confirmedChoice.value);
     };
     const onKeypress = (_str, key) => {
       if (!key)
@@ -6956,7 +7170,7 @@ async function promptToolApproval(params) {
     renderCard(1);
     return "yes";
   }
-  return new Promise((resolve18) => {
+  return new Promise((resolve17) => {
     let selectedIndex = 1;
     readline2.emitKeypressEvents(process.stdin);
     const wasRaw = process.stdin.isRaw;
@@ -6973,7 +7187,7 @@ async function promptToolApproval(params) {
         process.stdin.setRawMode(wasRaw ?? false);
       } catch {}
       console.log();
-      resolve18(val);
+      resolve17(val);
     };
     const onKeypress = (_str, key) => {
       if (!key)
@@ -7056,7 +7270,7 @@ async function promptUserQuestion(params) {
   if (!process.stdin.isTTY || false || !process.stdin.readable) {
     return options[0] || "yes";
   }
-  return new Promise((resolve18) => {
+  return new Promise((resolve17) => {
     const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
     const promptLabel = options.length > 0 ? `Select [1-${options.length}] or type custom response: ` : `Your response: `;
     rl.question(`  ${style.bold(promptLabel)}`, (answer) => {
@@ -7066,7 +7280,7 @@ async function promptUserQuestion(params) {
         const fallback = options[0] || "";
         console.log(style.dim(`  \u21B3 Default: ${fallback || "(empty)"}
 `));
-        resolve18(fallback);
+        resolve17(fallback);
         return;
       }
       const num = parseInt(trimmed, 10);
@@ -7074,26 +7288,26 @@ async function promptUserQuestion(params) {
         const picked = options[num - 1];
         console.log(style.green(`  \u2714 Selected: ${picked}
 `));
-        resolve18(picked);
+        resolve17(picked);
         return;
       }
       if (options.length === 2) {
         if (/^(y|yes)$/i.test(trimmed)) {
           console.log(style.green(`  \u2714 Selected: ${options[0]}
 `));
-          resolve18(options[0]);
+          resolve17(options[0]);
           return;
         }
         if (/^(n|no)$/i.test(trimmed)) {
           console.log(style.green(`  \u2714 Selected: ${options[1]}
 `));
-          resolve18(options[1]);
+          resolve17(options[1]);
           return;
         }
       }
       console.log(style.green(`  \u2714 Answer: ${trimmed}
 `));
-      resolve18(trimmed);
+      resolve17(trimmed);
     });
   });
 }
@@ -7122,7 +7336,7 @@ async function promptInteractiveList(config) {
 `);
     return { selectedIndex: -1, action: "close" };
   }
-  return new Promise((resolve18) => {
+  return new Promise((resolve17) => {
     let selectedIndex = Math.max(0, Math.min(defaultIndex, items.length - 1));
     let scrollTop = 0;
     let renderedLines = 0;
@@ -7214,7 +7428,7 @@ async function promptInteractiveList(config) {
       try {
         process.stdin.setRawMode(wasRaw ?? false);
       } catch {}
-      resolve18(res);
+      resolve17(res);
     };
     const onKeypress = async (_str, key) => {
       if (!key)
@@ -7285,8 +7499,8 @@ async function promptInteractiveList(config) {
 }
 
 // src/security/scanner.ts
-import { existsSync as existsSync18, readdirSync as readdirSync5, readFileSync as readFileSync13, statSync as statSync3 } from "fs";
-import { join as join9, relative as relative2, resolve as resolve18 } from "path";
+import { existsSync as existsSync17, readdirSync as readdirSync5, readFileSync as readFileSync12, statSync as statSync3 } from "fs";
+import { join as join8, relative as relative2, resolve as resolve17 } from "path";
 var SECURITY_RULES = [
   {
     id: "SEC-001",
@@ -7418,13 +7632,13 @@ var IGNORED_FILES = new Set([
 ]);
 async function runSecurityScan(targetDir, options = {}) {
   const startTime = performance.now();
-  const root = resolve18(targetDir);
+  const root = resolve17(targetDir);
   const isDirectTestDir = targetDir.includes("test") || Boolean(options.includeTests);
   const maxFiles = options.maxFiles || 2000;
   const findings = [];
   let scannedCount = 0;
   function walk(current) {
-    if (scannedCount >= maxFiles || !existsSync18(current))
+    if (scannedCount >= maxFiles || !existsSync17(current))
       return;
     let entries;
     try {
@@ -7435,7 +7649,7 @@ async function runSecurityScan(targetDir, options = {}) {
     for (const entry of entries) {
       if (scannedCount >= maxFiles)
         break;
-      const fullPath = join9(current, entry);
+      const fullPath = join8(current, entry);
       let stat;
       try {
         stat = statSync3(fullPath);
@@ -7466,7 +7680,7 @@ async function runSecurityScan(targetDir, options = {}) {
   function scanFile(filePath, baseRoot, ext, out) {
     let content;
     try {
-      content = readFileSync13(filePath, "utf8");
+      content = readFileSync12(filePath, "utf8");
     } catch {
       return;
     }
@@ -7513,34 +7727,34 @@ async function runSecurityScan(targetDir, options = {}) {
 }
 
 // src/mcp/servers/chrome-devtools/index.ts
-import { resolve as resolve19 } from "path";
+import { resolve as resolve18 } from "path";
 
 // src/mcp/servers/chrome-devtools/server.ts
 if (false) {}
 
 // src/mcp/servers/chrome-devtools/index.ts
 var __dirname = "/home/runner/work/agent-cli/agent-cli/src/mcp/servers/chrome-devtools";
-var CHROME_DEVTOOLS_MCP_SERVER_PATH = resolve19(__dirname, "server.ts");
+var CHROME_DEVTOOLS_MCP_SERVER_PATH = resolve18(__dirname, "server.ts");
 
 // src/mcp/servers/web-search/index.ts
-import { resolve as resolve20 } from "path";
+import { resolve as resolve19 } from "path";
 
 // src/mcp/servers/web-search/server.ts
 if (false) {}
 
 // src/mcp/servers/web-search/index.ts
 var __dirname = "/home/runner/work/agent-cli/agent-cli/src/mcp/servers/web-search";
-var WEB_SEARCH_MCP_SERVER_PATH = resolve20(__dirname, "server.ts");
+var WEB_SEARCH_MCP_SERVER_PATH = resolve19(__dirname, "server.ts");
 
 // src/mcp/servers/sqlite/index.ts
-import { resolve as resolve21 } from "path";
+import { resolve as resolve20 } from "path";
 
 // src/mcp/servers/sqlite/server.ts
 if (false) {}
 
 // src/mcp/servers/sqlite/index.ts
 var __dirname = "/home/runner/work/agent-cli/agent-cli/src/mcp/servers/sqlite";
-var SQLITE_MCP_SERVER_PATH = resolve21(__dirname, "server.ts");
+var SQLITE_MCP_SERVER_PATH = resolve20(__dirname, "server.ts");
 
 // src/cli/commands.ts
 var AVAILABLE_SLASH_COMMANDS = [
@@ -7550,6 +7764,11 @@ var AVAILABLE_SLASH_COMMANDS = [
   { name: "/reasoning", description: "Toggle internal reasoning chain visibility" },
   { name: "/login", description: "Authenticate with backend provider" },
   { name: "/whoami", description: "Check backend authentication status" },
+  { name: "/mode", description: "Cycle or set execution permission mode (auto, manual, accept-edits, plan)" },
+  { name: "/auto", description: "Switch to Auto Mode (tools execute automatically)" },
+  { name: "/manual", description: "Switch to Manual Mode (all tools require user confirmation)" },
+  { name: "/accept-edits", description: "Switch to Accept Edits Mode (file edits auto-approved, shell prompts)" },
+  { name: "/plan", description: "Switch to Plan Mode (read-only planning, mutations blocked)" },
   { name: "/skills", description: "List domain skills in workspace & global" },
   { name: "/memories", description: "View learned preferences & memories" },
   { name: "/worktrees", description: "List active isolated Git Worktrees" },
@@ -7601,6 +7820,37 @@ async function handleSlashCommand(input, ctx) {
     case "/roles":
       await handleRolesCommand(ctx, args[0]);
       return true;
+    case "/mode":
+    case "/modes":
+    case "/permission":
+    case "/permissions":
+      await handleModeCommand(ctx, args[0]);
+      return true;
+    case "/auto":
+      ctx.session.setPermissionMode("auto");
+      console.log(`
+  \x1B[38;2;255;215;0m\u23F5\u23F5 Switched to Auto Mode (tools execute automatically)\x1B[0m
+`);
+      return true;
+    case "/manual":
+      ctx.session.setPermissionMode("manual");
+      console.log(`
+  \x1B[38;2;148;148;148m\u23F8 Switched to Manual Mode (all tools require user confirmation)\x1B[0m
+`);
+      return true;
+    case "/accept-edits":
+    case "/acceptedits":
+      ctx.session.setPermissionMode("accept-edits");
+      console.log(`
+  \x1B[38;2;175;175;215m\u23F5\u23F5 Switched to Accept Edits Mode (file edits auto-approved, shell prompts)\x1B[0m
+`);
+      return true;
+    case "/plan":
+      ctx.session.setPermissionMode("plan");
+      console.log(`
+  \x1B[38;2;95;175;175m\u23F8 Switched to Plan Mode (read-only planning, mutations blocked)\x1B[0m
+`);
+      return true;
     case "/agents":
       printAgents(ctx);
       return true;
@@ -8517,6 +8767,84 @@ function printReleaseNotes() {
   console.log("  " + ROSE2 + "\u2514" + "\u2500".repeat(totalInnerWidth) + "\u2518" + RESET2);
   console.log("");
 }
+async function handleModeCommand(ctx, arg) {
+  const validModes = [
+    {
+      mode: "auto",
+      title: "Auto Mode",
+      desc: "Tools run automatically without confirmation (fastest autonomous workflow)",
+      glyph: "\u23F5\u23F5",
+      color: "\x1B[38;2;255;215;0m"
+    },
+    {
+      mode: "manual",
+      title: "Manual Mode",
+      desc: "Every file edit and shell command asks for user confirmation",
+      glyph: "\u23F8",
+      color: "\x1B[38;2;148;148;148m"
+    },
+    {
+      mode: "accept-edits",
+      title: "Accept Edits Mode",
+      desc: "File edits are auto-approved, but shell commands require approval",
+      glyph: "\u23F5\u23F5",
+      color: "\x1B[38;2;175;175;215m"
+    },
+    {
+      mode: "plan",
+      title: "Plan Mode",
+      desc: "Read-only mode. Blocks all mutations and focuses strictly on planning",
+      glyph: "\u23F8",
+      color: "\x1B[38;2;95;175;175m"
+    }
+  ];
+  const currentMode = ctx.session.permissionMode;
+  if (arg) {
+    const normalized = arg.trim().toLowerCase();
+    const match = validModes.find((m) => m.mode === normalized || m.mode.replace("-", "") === normalized);
+    if (match) {
+      ctx.session.setPermissionMode(match.mode);
+      console.log(`
+  ${match.color}${match.glyph} Switched to ${match.title}\x1B[0m
+  ${style.dim(match.desc)}
+`);
+      return;
+    }
+  }
+  if (!process.stdin.isTTY || false || !process.stdin.readable) {
+    console.log(`
+  Current Permission Mode: ${style.bold(currentMode)}`);
+    for (const m of validModes) {
+      const active = m.mode === currentMode ? " (active)" : "";
+      console.log(`  \u2022 ${m.title}${active}: ${m.desc}`);
+    }
+    console.log();
+    return;
+  }
+  const items = validModes.map((m) => ({
+    id: m.mode,
+    label: `${m.glyph} ${m.title}`,
+    badge: m.mode === currentMode ? "ACTIVE" : undefined,
+    description: m.desc,
+    checked: m.mode === currentMode
+  }));
+  const res = await promptInteractiveList({
+    title: "\uD83C\uDF9B\uFE0F Select Execution Permission Mode (Shift+Tab in prompt to cycle)",
+    items,
+    mode: "select",
+    customKeyHints: "\u2191/\u2193: navigate \xB7 Enter: switch mode \xB7 Esc: cancel"
+  });
+  if (res.action === "select" && res.selectedItem) {
+    const chosen = validModes.find((m) => m.mode === res.selectedItem?.id);
+    if (chosen) {
+      ctx.session.setPermissionMode(chosen.mode);
+      console.log(`
+  ${chosen.color}${chosen.glyph} Switched to ${chosen.title}\x1B[0m
+  ${style.dim(chosen.desc)}
+`);
+    }
+  }
+}
 
 // src/cli/ui/markdown.ts
 class MarkdownHighlighter {
@@ -8788,9 +9116,9 @@ class MarkdownHighlighter {
 }
 
 // src/cli/update-checker.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync10, readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir9 } from "os";
-import { join as join10 } from "path";
+import { join as join9 } from "path";
 var CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000;
 function parseSemver(v) {
   const clean = v.replace(/^v/, "").trim();
@@ -8811,8 +9139,8 @@ function isNewerVersion(current, remote) {
   return remPatch > curPatch;
 }
 function getUpdateCachePath() {
-  const baseDir = process.env.PIKAA_HOME || process.env.GROUPY_HOME || join10(homedir9(), ".pikaa");
-  return join10(baseDir, "update-cache.json");
+  const baseDir = process.env.PIKAA_HOME || process.env.GROUPY_HOME || join9(homedir9(), ".pikaa");
+  return join9(baseDir, "update-cache.json");
 }
 async function fetchLatestNpmVersion(packageName, timeoutMs = 1500) {
   const url = `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
@@ -8845,9 +9173,9 @@ async function checkForUpdates(options = {}) {
   const cachePath = options.cachePath || getUpdateCachePath();
   const now = Date.now();
   let cached = null;
-  if (!options.force && existsSync19(cachePath)) {
+  if (!options.force && existsSync18(cachePath)) {
     try {
-      const raw = JSON.parse(readFileSync14(cachePath, "utf8"));
+      const raw = JSON.parse(readFileSync13(cachePath, "utf8"));
       if (raw && typeof raw.lastChecked === "number" && typeof raw.latestVersion === "string") {
         cached = raw;
         if (now - cached.lastChecked < CHECK_INTERVAL_MS) {
@@ -8875,8 +9203,8 @@ async function checkForUpdates(options = {}) {
     return null;
   }
   try {
-    const parentDir = join10(cachePath, "..");
-    if (!existsSync19(parentDir)) {
+    const parentDir = join9(cachePath, "..");
+    if (!existsSync18(parentDir)) {
       mkdirSync10(parentDir, { recursive: true });
     }
     const cacheData = {
@@ -9049,9 +9377,9 @@ class CliRepl {
             filesModified: Array.from(this.turnFilesModified)
           });
           if (this.turnDoneResolver) {
-            const resolve22 = this.turnDoneResolver;
+            const resolve21 = this.turnDoneResolver;
             this.turnDoneResolver = undefined;
-            resolve22();
+            resolve21();
           }
           break;
         case "Error":
@@ -9067,9 +9395,9 @@ class CliRepl {
           console.error(style.red(`Error: ${msg.message}
 `));
           if (this.turnDoneResolver) {
-            const resolve22 = this.turnDoneResolver;
+            const resolve21 = this.turnDoneResolver;
             this.turnDoneResolver = undefined;
-            resolve22();
+            resolve21();
           }
           break;
       }
@@ -9124,6 +9452,10 @@ class CliRepl {
     }).catch(() => {});
     const editor = new InteractiveLineEditor({
       cwd: this.session.cwd,
+      initialMode: this.session.permissionMode,
+      onModeChange: (newMode) => {
+        this.session.setPermissionMode(newMode);
+      },
       onInterrupt: () => {
         if (this.isProcessing) {
           const activeTurn = this.session.getActiveTurn();
@@ -9135,9 +9467,9 @@ class CliRepl {
 `));
             this.isProcessing = false;
             if (this.turnDoneResolver) {
-              const resolve22 = this.turnDoneResolver;
+              const resolve21 = this.turnDoneResolver;
               this.turnDoneResolver = undefined;
-              resolve22();
+              resolve21();
             }
           }
         }
@@ -9169,8 +9501,8 @@ class CliRepl {
         }
       }
       try {
-        const turnPromise = new Promise((resolve22) => {
-          this.turnDoneResolver = resolve22;
+        const turnPromise = new Promise((resolve21) => {
+          this.turnDoneResolver = resolve21;
         });
         await this.session.submit({
           type: "TurnInput",
@@ -9258,7 +9590,7 @@ async function main() {
       explicitApiKey = args[++i];
       apiKey = explicitApiKey || apiKey;
     } else if (arg === "--cwd" || arg === "-C") {
-      cwd = resolve22(args[++i] || cwd);
+      cwd = resolve21(args[++i] || cwd);
     } else if (arg === "--role" || arg === "-r") {
       role = args[++i] || role;
     } else if (arg === "--mcp") {
@@ -9284,11 +9616,11 @@ async function main() {
   const mcpManager = new McpManager;
   const candidateConfigs = [
     mcpConfigFile,
-    resolve22(cwd, ".mcp.json"),
-    resolve22(cwd, "mcp_config.json")
+    resolve21(cwd, ".mcp.json"),
+    resolve21(cwd, "mcp_config.json")
   ].filter(Boolean);
   for (const cfg of candidateConfigs) {
-    if (existsSync20(cfg)) {
+    if (existsSync19(cfg)) {
       try {
         await mcpManager.loadConfigFile(cfg);
         mcpManager.registerToolsIntoRouter(tools4);

package/dist/index.js

@@ -1648,6 +1648,22 @@ var applyPatchTool = {
     const filePath = resolve2(ctx.cwd, rawPath);
     const targetContent = typeof args.targetContent === "string" ? args.targetContent : "";
     const replacementContent = String(args.replacementContent ?? "");
+    if (ctx.execPolicy) {
+      const evalResult = ctx.execPolicy.shouldPromptFileEdit(rawPath);
+      if (evalResult.isPlanBlocked || ctx.mode === "plan") {
+        return {
+          output: "Error: Cannot mutate files while in Plan Mode. Please present the implementation plan first.",
+          isError: true
+        };
+      }
+      if (evalResult.prompt && ctx.requestApproval) {
+        const approval = await ctx.requestApproval(`Apply patch to: ${rawPath}`, `apply_patch ${rawPath}`);
+        const allowed = typeof approval === "object" ? approval.allowed : Boolean(approval);
+        if (!allowed) {
+          return { output: `Action rejected by user: apply_patch '${rawPath}'`, isError: true };
+        }
+      }
+    }
     if (!existsSync2(filePath)) {
       if (targetContent) {
         return {
@@ -1704,9 +1720,17 @@ var applyPatchTool = {
 // src/security/exec-policy.ts
 class ExecPolicy {
   rules = [];
-  constructor() {
+  mode = "auto";
+  constructor(initialMode = "auto") {
+    this.mode = initialMode;
     this.initDefaultRules();
   }
+  getMode() {
+    return this.mode;
+  }
+  setMode(mode) {
+    this.mode = mode;
+  }
   initDefaultRules() {
     this.addRule(/^(git\s+(status|log|diff|branch|show|rev-parse))/i, "allow", "Safe git query");
     this.addRule(/^(ls|dir|cat|type|grep|rg|find|pwd|echo|head|tail|wc|which|where)\b/i, "allow", "Safe read-only shell command");
@@ -1718,8 +1742,47 @@ class ExecPolicy {
   addRule(pattern, decision, description) {
     this.rules.unshift({ pattern, decision, description });
   }
+  shouldPromptFileEdit(filePath) {
+    if (this.mode === "plan") {
+      return {
+        prompt: false,
+        isPlanBlocked: true,
+        reason: "Plan Mode is active. Mutating files is not allowed while planning."
+      };
+    }
+    if (this.mode === "manual") {
+      return {
+        prompt: true,
+        reason: `Manual mode requires approval to modify '${filePath || "file"}'`
+      };
+    }
+    return { prompt: false };
+  }
   evaluate(command) {
     const trimmed = command.trim();
+    if (this.mode === "plan") {
+      const isReadOnly = /^(git\s+(status|log|diff|branch|show)|ls|dir|cat|type|grep|rg|find|pwd|which|where)\b/i.test(trimmed);
+      if (isReadOnly) {
+        return { decision: "allow", reason: "Read-only inspection allowed in Plan mode" };
+      }
+      return { decision: "deny", reason: "Cannot execute mutating shell commands in Plan mode" };
+    }
+    if (this.mode === "manual") {
+      return {
+        decision: "prompt",
+        reason: "Manual mode requires confirmation for all shell commands"
+      };
+    }
+    if (this.mode === "accept-edits") {
+      const isReadOnly = /^(git\s+(status|log|diff|branch|show)|ls|dir|cat|type|grep|rg|find|pwd|bun\s+test|npm\s+test)\b/i.test(trimmed);
+      if (isReadOnly) {
+        return { decision: "allow", reason: "Safe read-only command in accept-edits mode" };
+      }
+      return {
+        decision: "prompt",
+        reason: "Accept-edits mode requires approval for active shell commands"
+      };
+    }
     for (const rule of this.rules) {
       if (rule.pattern.test(trimmed)) {
         return {
@@ -1729,8 +1792,8 @@ class ExecPolicy {
       }
     }
     return {
-      decision: "prompt",
-      reason: "Command is not in the automatic allowlist"
+      decision: "allow",
+      reason: "Auto mode allows execution"
     };
   }
 }
@@ -2316,7 +2379,24 @@ var writeFileTool = {
     required: ["path", "content"]
   },
   async execute(args, ctx) {
-    const filePath = resolve5(ctx.cwd, String(args.path || ""));
+    const rawPath = String(args.path || "");
+    const filePath = resolve5(ctx.cwd, rawPath);
+    if (ctx.execPolicy) {
+      const evalResult = ctx.execPolicy.shouldPromptFileEdit(rawPath);
+      if (evalResult.isPlanBlocked || ctx.mode === "plan") {
+        return {
+          output: "Error: Cannot write or mutate files while in Plan Mode. Please present the implementation plan first.",
+          isError: true
+        };
+      }
+      if (evalResult.prompt && ctx.requestApproval) {
+        const approval = await ctx.requestApproval(`Write file: ${rawPath}`, `write_file ${rawPath}`);
+        const allowed = typeof approval === "object" ? approval.allowed : Boolean(approval);
+        if (!allowed) {
+          return { output: `Action rejected by user: write_file '${rawPath}'`, isError: true };
+        }
+      }
+    }
     try {
       mkdirSync4(dirname3(filePath), { recursive: true });
       writeFileSync3(filePath, String(args.content ?? ""), "utf8");
@@ -3881,6 +3961,7 @@ async function runTurn(session, turnContext, input) {
             signal,
             execPolicy: session.execPolicy,
             mode: session.collaborationMode,
+            permissionMode: session.permissionMode,
             onPlanUpdate: (plan2, explanation) => {
               session.emitEvent({
                 type: "PlanUpdated",
@@ -4041,6 +4122,17 @@ class Session {
   mcpManager;
   execPolicy;
   collaborationMode = "default";
+  get permissionMode() {
+    return this.execPolicy.getMode();
+  }
+  setPermissionMode(mode) {
+    this.execPolicy.setMode(mode);
+    if (mode === "plan") {
+      this.collaborationMode = "plan";
+    } else if (this.collaborationMode === "plan") {
+      this.collaborationMode = "default";
+    }
+  }
   history = [];
   activeTurn = null;
   status = "idle";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikaa-ai/pikaa",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "PIKAA CLI - AI coding agent that runs locally in your terminal.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/templates/base/groupy_prompt.md

@@ -15,9 +15,75 @@ You are Groupy, an expert autonomous AI coding assistant. You are running as a c
     * If the changes are in files you've touched recently, you should read carefully and understand how you can work with the changes rather than reverting them.
     * If the changes are in unrelated files, just ignore them and don't revert them.
 - Do not amend a commit unless explicitly requested to do so.
-- While you are working, you might notice unexpected changes that you didn't make. If this happens, STOP IMMEDIATELY and ask the user how they would like to proceed.
 - **NEVER** use destructive commands like `git reset --hard` or `git checkout --` unless specifically requested or approved by the user.
 
+## Adaptive Task Routing (Automatic Complexity Detection)
+
+1. **Small / Standard Tasks (Single component, straightforward, < 3 files)**:
+   - Proceed directly to execution with zero overhead. Do not create heavy plans or ask trivial confirmation questions.
+   - Code surgically and verify with automated tests.
+
+2. **Large / Complex / Ambiguous Tasks (> 3 files, architectural overhaul, new subsystem)**:
+   - **Step 1 (Auto-Plan)**: Outline a brief step-by-step Implementation Plan before modifying files.
+   - **Step 2 (Clarify Ambiguity & Present Choices)**: If there are architectural trade-offs or underspecified requirements, pause and present numbered choices with Option 1 marked as `(Recommended)`.
+   - **Step 3 (Execute & Delegate)**: Once the user confirms, execute systematically. Autonomously spawn specialized sub-agents (`spawn_agent`) for independent sub-tasks (e.g. `security-auditor`, `frontend-designer`, `tester`, `researcher`).
+   - **Step 4 (Verify)**: Run full build and test suites, automatically repairing any failures before concluding.
+
+## Clarifications, Decision Branching & Recommendations
+
+1. **Avoid Trivial Questions**:
+   - For routine decisions (naming, syntax, sensible standard defaults), use industry best practices and proceed autonomously without bothering the user.
+
+2. **When to Pause & Clarify (Ambiguity & Trade-offs)**:
+   - Pause and ask if you encounter:
+     * Significantly underspecified requirements (e.g., storage driver, auth strategy, deployment target).
+     * Potential breaking changes affecting existing modules.
+     * Large architectural choices with distinct trade-offs.
+
+3. **Recommendation Format**:
+   - Always format choices as clear, numbered options (`1.`, `2.`, `3.`).
+   - Place your best technical recommendation as Option 1 prefixed with `(Recommended)`.
+   - Keep options concise so the user can reply instantly with a single number.
+
+## Codebase Discovery & Execution Strategy
+
+1. **Broad Exploration ("pelajari project ini / repo ini tentang apa")**:
+   - Inspect ONLY root configs (`package.json`, `Cargo.toml`, `go.mod`, `pyproject.toml`, etc.), `README.md`, and top-level directory tree.
+   - Deliver a concise Architecture Overview (Tech stack, folder hierarchy, main entry points).
+   - Do NOT read full component or implementation files during initial reconnaissance. Stop and ask the user what to build or investigate next.
+
+2. **Direct Feature Requests ("buat fitur X")**:
+   - Do NOT scan or read unrelated files across the repo.
+   - Use `grep_search` or `find_files` to pinpoint the exact target area.
+   - Read ONLY 1-2 existing reference files to understand established patterns, naming conventions, and shared utilities (avoid reinventing the wheel).
+   - Implement the minimal, clean, and robust code needed to satisfy the request.
+
+3. **Bug Fixes & Diagnostics ("kenapa error X / perbaiki bug Y")**:
+   - Trace from the reported symptom using `grep_search` to find all callers and the shared function.
+   - Fix the root cause in the shared module once, rather than applying band-aid patches across callers.
+
+## Mandatory Verification, Testing & Self-Repair Loop
+
+Before considering any task complete, you MUST execute the following verification steps:
+
+1. **Write Automated Tests**:
+   - For any non-trivial logic, new feature, or bug fix, write a clean and targeted test suite (or update existing tests).
+   - Ensure the test covers edge cases and specifically verifies that the bug cannot regress.
+
+2. **Run Build & Test Validation (Platform & Stack Specific)**:
+   Detect the project type and execute the appropriate validation command via terminal:
+   - **TypeScript / JavaScript (Node, Bun, Deno)**: Run `bun test` / `npm test`, `tsc --noEmit`, or `npm run build`.
+   - **Rust**: Run `cargo check`, `cargo test`, and `cargo build`.
+   - **Go**: Run `go test ./...` and `go build`.
+   - **Python**: Run `pytest` or `python -m unittest`, and verify syntax with `python -m py_compile <files>` or `mypy`.
+   - **Java / Kotlin**: Run `./gradlew test` / `mvn test` and verify compile.
+   - **C / C++ / C#**: Run project build / test targets (`dotnet test`, `cmake --build`, `make test`).
+
+3. **Autonomous Self-Repair (Do Not Stop on Error)**:
+   - If tests fail, types mismatch, or the build produces compilation errors, do NOT stop and report failure immediately.
+   - Inspect the compiler/runtime stack trace, diagnose the exact failure, apply the fix, and re-run verification until all checks pass cleanly.
+   - Only conclude your turn once the code compiles, builds, and passes all tests.
+
 ## Skills & Autonomous Domain Knowledge
 
 You have access to specialized domain skills listed in `<available_skills>`.