@dv.nghiem/flowdeck 0.4.11 → 0.4.12

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import { readFileSync as readFileSync25, readdirSync as readdirSync3, existsSync as existsSync27 } from "fs";
-import { join as join26, basename as basename2 } from "path";
+import { readFileSync as readFileSync25, readdirSync as readdirSync3, existsSync as existsSync26 } from "fs";
+import { join as join25, basename as basename2 } from "path";
 import { dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -1807,212 +1807,25 @@ var listRulesTool = tool11({
   }
 });
 
-// src/tools/rtk-setup.ts
+// src/tools/merge-assist.ts
 import { tool as tool12 } from "@opencode-ai/plugin";
-
-// src/services/rtk-manager.ts
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync11, existsSync as existsSync15, mkdirSync as mkdirSync10 } from "fs";
+import { join as join15 } from "path";
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync14 } from "fs";
-import { homedir } from "os";
-import { join as join14 } from "path";
-
-// src/services/rtk-policy.ts
-var SUPPORTED_COMMANDS = new Set([
-  "git",
-  "npm",
-  "npx",
-  "bun",
-  "pnpm",
-  "yarn",
-  "tsc",
-  "eslint",
-  "biome",
-  "oxlint",
-  "jest",
-  "vitest",
-  "pytest",
-  "cargo",
-  "docker",
-  "kubectl",
-  "gh"
-]);
-var COMPACT_GIT_SUBCOMMANDS = new Set([
-  "rev-parse",
-  "hash-object",
-  "cat-file",
-  "ls-files",
-  "ls-tree",
-  "show-ref",
-  "for-each-ref",
-  "symbolic-ref",
-  "config"
-]);
-var NEVER_WRAP = new Set(["codegraph", "curl", "sh", "bash", "zsh", "fish", "node", "python", "python3"]);
-function getSupportedCommands() {
-  return [...SUPPORTED_COMMANDS].sort();
-}
-
-// src/services/rtk-manager.ts
-var INSTALL_INSTRUCTIONS = [
-  "rtk is not installed. To install it manually:",
-  "  Linux/macOS: curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh",
-  "  Then add ~/.local/bin to your PATH if needed.",
-  "After installation, call rtk-setup again to verify detection."
-].join(`
-`);
-var CANDIDATE_PATHS = [join14(homedir(), ".local", "bin", "rtk"), "/usr/local/bin/rtk", "/usr/bin/rtk"];
-function detectRtk() {
-  const fromPath = spawnSync2("rtk", ["--version"], { encoding: "utf-8", timeout: 5000 });
-  if (fromPath.status === 0) {
-    const version = (fromPath.stdout ?? "").trim().split(`
-`)[0] ?? "";
-    return { installed: true, binPath: "rtk", version };
-  }
-  for (const candidate of CANDIDATE_PATHS) {
-    if (!existsSync14(candidate))
-      continue;
-    const result = spawnSync2(candidate, ["--version"], { encoding: "utf-8", timeout: 5000 });
-    if (result.status === 0) {
-      const version = (result.stdout ?? "").trim().split(`
-`)[0] ?? "";
-      return { installed: true, binPath: candidate, version };
-    }
-  }
-  return {
-    installed: false,
-    error: "rtk binary not found in PATH or known install locations"
-  };
-}
-function initRtk(binPath) {
-  try {
-    const result = spawnSync2(binPath, ["init", "-g"], {
-      encoding: "utf-8",
-      timeout: 30000,
-      stdio: "pipe"
-    });
-    if (result.status !== 0) {
-      return {
-        success: false,
-        log: (result.stdout ?? "").trim(),
-        telemetryDisabled: false,
-        error: (result.stderr ?? "").trim() || `rtk init -g exited with code ${result.status}`
-      };
-    }
-    const telResult = spawnSync2(binPath, ["telemetry", "disable"], {
-      encoding: "utf-8",
-      timeout: 1e4,
-      stdio: "pipe"
-    });
-    return {
-      success: true,
-      log: [
-        `[rtk] init -g succeeded: ${(result.stdout ?? "").trim()}`,
-        `[rtk] telemetry disable: ${telResult.status === 0 ? "ok" : `failed (code ${telResult.status}) — ${(telResult.stderr ?? "").trim()}`}`
-      ].filter(Boolean).join(`
-`),
-      telemetryDisabled: telResult.status === 0
-    };
-  } catch (err) {
-    return { success: false, log: "", telemetryDisabled: false, error: String(err) };
-  }
-}
-function getRtkStatus(opts) {
-  const detection = detectRtk();
-  if (!detection.installed) {
-    return {
-      installed: false,
-      initAttempted: false,
-      initSuccess: false,
-      telemetryDisabled: false,
-      installInstructions: INSTALL_INSTRUCTIONS
-    };
-  }
-  let initAttempted = false;
-  let initSuccess = false;
-  let telemetryDisabled = false;
-  if (opts?.runInit && detection.binPath) {
-    initAttempted = true;
-    const initResult = initRtk(detection.binPath);
-    initSuccess = initResult.success;
-    telemetryDisabled = initResult.telemetryDisabled;
-  }
-  return {
-    installed: true,
-    binPath: detection.binPath,
-    version: detection.version,
-    initAttempted,
-    initSuccess,
-    telemetryDisabled
-  };
-}
-
-// src/tools/rtk-setup.ts
-var rtkSetupTool = tool12({
-  description: [
-    "Detect, initialize, and report status of rtk (output compression proxy for CLI commands).",
-    "rtk reduces noisy CLI output (git, npm, test runners, linters, docker) by 60-90%.",
-    "Call this to check if rtk is available, to run `rtk init -g`, or to get the binary path.",
-    "When RTK_INSTALLED=true in the environment, use `$RTK_BIN git status` for compressed output."
-  ].join(" "),
-  args: {
-    action: tool12.schema.enum(["status", "init"]).optional().describe("'status' — detect and report rtk state (default). " + "'init' — detect, then run `rtk init -g` to install the bash hook. " + "Use 'init' only once per environment setup.")
-  },
-  async execute(args) {
-    const action = args.action ?? "status";
-    const runInit = action === "init";
-    const status = getRtkStatus({ runInit });
-    const lines = ["## rtk Status"];
-    if (status.installed) {
-      lines.push(`- **Installed**: yes`);
-      lines.push(`- **Binary**: ${status.binPath ?? "rtk (in PATH)"}`);
-      if (status.version)
-        lines.push(`- **Version**: ${status.version}`);
-      if (runInit) {
-        if (status.initAttempted) {
-          lines.push(`- **Init**: ${status.initSuccess ? "✓ succeeded (bash hook installed)" : "✗ failed"}`);
-          lines.push(`- **Telemetry**: ${status.telemetryDisabled ? "✓ disabled (`rtk telemetry disable` ran)" : "⚠ disable step failed — run `rtk telemetry disable` manually"}`);
-          if (status.initSuccess) {
-            lines.push("", "  **Bash hook caveat**: `rtk init -g` writes to Claude Code / Copilot global config.", "  Whether it fires in non-interactive shell sessions depends on the runtime.", "  For reliable compression, use `$RTK_BIN <cmd>` explicitly.", "  `RTK_TELEMETRY_DISABLED=1` is always injected into bash sessions by FlowDeck.");
-          }
-        }
-      } else {
-        lines.push("- **Init**: not requested (pass `action: 'init'` to install bash hook)");
-        lines.push("- **Telemetry**: `RTK_TELEMETRY_DISABLED=1` is always set in bash sessions by FlowDeck");
-      }
-      lines.push("", "### Using rtk", "In bash commands, replace `git status` with `$RTK_BIN git status`.", "The `RTK_BIN` env var is injected by FlowDeck into every bash session when rtk is detected.", "", "### Supported commands", getSupportedCommands().map((c) => `- \`${c}\``).join(`
-`));
-    } else {
-      lines.push("- **Installed**: no", "");
-      lines.push("### Install rtk");
-      if (status.installInstructions) {
-        lines.push("```", status.installInstructions, "```");
-      }
-      lines.push("", "After installing, call `rtk-setup` again to verify detection.");
-    }
-    return lines.join(`
-`);
-  }
-});
-
-// src/tools/merge-assist.ts
-import { tool as tool13 } from "@opencode-ai/plugin";
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync11, existsSync as existsSync16, mkdirSync as mkdirSync10 } from "fs";
-import { join as join16 } from "path";
-import { spawnSync as spawnSync3 } from "child_process";
 
 // src/lib/logger.ts
-import { appendFileSync as appendFileSync3, existsSync as existsSync15, mkdirSync as mkdirSync9 } from "fs";
-import { join as join15 } from "path";
+import { appendFileSync as appendFileSync3, existsSync as existsSync14, mkdirSync as mkdirSync9 } from "fs";
+import { join as join14 } from "path";
 var LOG_DIR = ".opencode";
 var LOG_FILE = "flowdeck.log";
 function ensureLogDir(logDir) {
-  if (!existsSync15(logDir)) {
+  if (!existsSync14(logDir)) {
     mkdirSync9(logDir, { recursive: true });
   }
 }
 function logWrite(directory, level, source, message) {
-  const logDir = join15(directory, LOG_DIR);
-  const logFile = join15(logDir, LOG_FILE);
+  const logDir = join14(directory, LOG_DIR);
+  const logFile = join14(logDir, LOG_FILE);
   try {
     ensureLogDir(logDir);
     const entry = {
@@ -2029,14 +1842,14 @@ function logWrite(directory, level, source, message) {
 // src/tools/merge-assist.ts
 var MERGE_ASSIST_FILE = "MERGE_ASSIST.json";
 function statePath2(directory) {
-  return join16(codebaseDir(directory), MERGE_ASSIST_FILE);
+  return join15(codebaseDir(directory), MERGE_ASSIST_FILE);
 }
 function emptyState() {
   return { version: "1.0", lastUpdated: new Date().toISOString(), sessions: {} };
 }
 function readState(directory) {
   const p = statePath2(directory);
-  if (!existsSync16(p))
+  if (!existsSync15(p))
     return emptyState();
   try {
     return JSON.parse(readFileSync15(p, "utf-8"));
@@ -2047,7 +1860,7 @@ function readState(directory) {
 function writeState(directory, state) {
   try {
     const base = codebaseDir(directory);
-    if (!existsSync16(base))
+    if (!existsSync15(base))
       mkdirSync10(base, { recursive: true });
     const newState = { ...state, lastUpdated: new Date().toISOString() };
     writeFileSync11(statePath2(directory), JSON.stringify(newState, null, 2), "utf-8");
@@ -2063,7 +1876,7 @@ function generateId() {
   return `ma-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
 function safeGit(cwd, args) {
-  const result = spawnSync3("git", args, { cwd, encoding: "utf-8" });
+  const result = spawnSync2("git", args, { cwd, encoding: "utf-8" });
   return {
     stdout: result.stdout?.trim() ?? "",
     stderr: result.stderr?.trim() ?? "",
@@ -2071,7 +1884,7 @@ function safeGit(cwd, args) {
   };
 }
 function isGitRepo(cwd) {
-  return existsSync16(join16(cwd, ".git")) && safeGit(cwd, ["rev-parse", "--git-dir"]).status === 0;
+  return existsSync15(join15(cwd, ".git")) && safeGit(cwd, ["rev-parse", "--git-dir"]).status === 0;
 }
 function branchExists(cwd, branch) {
   return safeGit(cwd, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]).status === 0;
@@ -2254,18 +2067,18 @@ function updateConfirmation(session, step, approved) {
 function isStepApproved(session, step) {
   return session.confirmations.some((c) => c.step === step && c.status === "approved");
 }
-var mergeAssistTool = tool13({
+var mergeAssistTool = tool12({
   description: "Human-in-the-loop selective branch integration. Provides structured analysis and confirmation state management for cherry-pick or manual port workflows. Never executes state-changing git commands.",
   args: {
-    action: tool13.schema.enum(["start", "inspect", "plan", "confirm", "abort", "status", "list"]),
-    targetBranch: tool13.schema.string().optional(),
-    sourceBranch: tool13.schema.string().optional(),
-    featureDescription: tool13.schema.string().optional(),
-    sessionId: tool13.schema.string().optional(),
-    selectedCommits: tool13.schema.array(tool13.schema.string()).optional(),
-    step: tool13.schema.string().optional(),
-    approved: tool13.schema.boolean().optional(),
-    integrationBranch: tool13.schema.string().optional()
+    action: tool12.schema.enum(["start", "inspect", "plan", "confirm", "abort", "status", "list"]),
+    targetBranch: tool12.schema.string().optional(),
+    sourceBranch: tool12.schema.string().optional(),
+    featureDescription: tool12.schema.string().optional(),
+    sessionId: tool12.schema.string().optional(),
+    selectedCommits: tool12.schema.array(tool12.schema.string()).optional(),
+    step: tool12.schema.string().optional(),
+    approved: tool12.schema.boolean().optional(),
+    integrationBranch: tool12.schema.string().optional()
   },
   async execute(args, context) {
     const dir = context.directory ?? process.cwd();
@@ -2470,8 +2283,8 @@ var mergeAssistTool = tool13({
 });
 
 // src/hooks/guard-rails.ts
-import { existsSync as existsSync18, readFileSync as readFileSync17 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync17 } from "fs";
+import { join as join17 } from "path";
 
 // src/lib/task-routing.ts
 var UI_HEAVY_KEYWORDS = [
@@ -2517,21 +2330,21 @@ function isUiHeavyTask(input) {
 }
 
 // src/config/loader.ts
-import { existsSync as existsSync17, readFileSync as readFileSync16 } from "fs";
-import { join as join17 } from "path";
-import { homedir as homedir2 } from "os";
+import { existsSync as existsSync16, readFileSync as readFileSync16 } from "fs";
+import { join as join16 } from "path";
+import { homedir } from "os";
 var CONFIG_FILENAME = "flowdeck.json";
 function getGlobalConfigDir() {
-  return process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? join17(process.env.XDG_CONFIG_HOME, "opencode") : join17(homedir2(), ".config", "opencode"));
+  return process.env.OPENCODE_CONFIG_DIR || (process.env.XDG_CONFIG_HOME ? join16(process.env.XDG_CONFIG_HOME, "opencode") : join16(homedir(), ".config", "opencode"));
 }
 function loadFlowDeckConfig(directory) {
   const candidates = [];
   if (directory) {
-    candidates.push(join17(directory, ".opencode", CONFIG_FILENAME));
+    candidates.push(join16(directory, ".opencode", CONFIG_FILENAME));
   }
-  candidates.push(join17(getGlobalConfigDir(), CONFIG_FILENAME));
+  candidates.push(join16(getGlobalConfigDir(), CONFIG_FILENAME));
   for (const configPath of candidates) {
-    if (existsSync17(configPath)) {
+    if (existsSync16(configPath)) {
       try {
         const content = readFileSync16(configPath, "utf-8");
         return JSON.parse(content);
@@ -2560,7 +2373,7 @@ var PLANNING_DIR2 = ".planning";
 var CONFIG_FILE = "config.json";
 var STATE_FILE2 = "STATE.md";
 function resolveExecutionMode(configPath, trustScore, volatility) {
-  if (existsSync18(configPath)) {
+  if (existsSync17(configPath)) {
     try {
       const config = JSON.parse(readFileSync17(configPath, "utf-8"));
       if (config.execution_mode === "review-only")
@@ -2616,22 +2429,22 @@ async function guardRailsHook(ctx, input, _output) {
   if (!ENABLED)
     return;
   const dir = ctx.directory;
-  const planningDirPath = join18(dir, PLANNING_DIR2);
+  const planningDirPath = join17(dir, PLANNING_DIR2);
   const codebaseDirectory = codebaseDir(dir);
-  const configPath = join18(planningDirPath, CONFIG_FILE);
-  const statePath3 = join18(planningDirPath, STATE_FILE2);
+  const configPath = join17(planningDirPath, CONFIG_FILE);
+  const statePath3 = join17(planningDirPath, STATE_FILE2);
   const workspaceRoot = findWorkspaceRoot(dir);
   if (workspaceRoot && dir !== workspaceRoot) {
     const config = getWorkspaceConfig(dir);
-    if (config && config.workspace_mode === "shared" && !existsSync18(planningDirPath)) {
+    if (config && config.workspace_mode === "shared" && !existsSync17(planningDirPath)) {
       const msg = `No .planning/ in this sub-repo. Switch to workspace root: cd ${workspaceRoot}`;
       throw new Error(`[flowdeck] BLOCK: ${msg}`);
     }
   }
   if (input.tool === "write" || input.tool === "edit") {
-    if (!existsSync18(planningDirPath))
+    if (!existsSync17(planningDirPath))
       return;
-    if (!existsSync18(codebaseDirectory)) {
+    if (!existsSync17(codebaseDirectory)) {
       throw new Error(`[flowdeck] WARNING: .codebase/ not found. Run /fd-map-codebase to map the codebase.`);
     }
     const execMode = resolveExecutionMode(configPath, null);
@@ -2687,13 +2500,13 @@ function getDesignGateMessage(dir) {
 }
 function planSuggestsUiHeavy(dir, phase) {
   const planPath = phasePlanPath(dir, phase);
-  if (!existsSync18(planPath))
+  if (!existsSync17(planPath))
     return false;
   const planContent = readFileSync17(planPath, "utf-8");
   return isUiHeavyTask(planContent);
 }
 function effectiveSeverity(configPath, statePath3) {
-  if (existsSync18(configPath)) {
+  if (existsSync17(configPath)) {
     try {
       const configContent = readFileSync17(configPath, "utf-8");
       const config = JSON.parse(configContent);
@@ -2711,7 +2524,7 @@ function getEffectiveSeverity(configPath, statePath3) {
   return effectiveSeverity(configPath, statePath3);
 }
 function getPlanConfirmed(statePath3) {
-  if (!existsSync18(statePath3))
+  if (!existsSync17(statePath3))
     return false;
   try {
     const content = readFileSync17(statePath3, "utf-8");
@@ -2722,32 +2535,32 @@ function getPlanConfirmed(statePath3) {
   }
 }
 function getWarningMessage(planningDir2) {
-  if (!existsSync18(join18(planningDir2, STATE_FILE2))) {
+  if (!existsSync17(join17(planningDir2, STATE_FILE2))) {
     return "No STATE.md found. Run /fd-map-codebase then /fd-new-feature to start a feature.";
   }
   return "Plan not confirmed. Run /fd-plan and confirm to enable execution.";
 }
 function getBlockMessage(planningDir2) {
-  if (!existsSync18(join18(planningDir2, STATE_FILE2))) {
+  if (!existsSync17(join17(planningDir2, STATE_FILE2))) {
     return "No STATE.md found. Run /fd-map-codebase then /fd-new-feature to start a feature.";
   }
   return "Plan not confirmed. Run /fd-plan and confirm to enable execution.";
 }
 
 // src/hooks/tool-guard.ts
-import { existsSync as existsSync19, readFileSync as readFileSync18 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync18 } from "fs";
+import { join as join18 } from "path";
 var IS_ENABLED = () => process.env.FLOWDECK_TOOL_GUARD_ENABLED === "on";
 var BLOCKED_PATTERNS = {
   read: [".env", ".pem", ".key", ".secret"],
   write: ["node_modules"],
   bash: ["rm -rf"]
 };
-function isBlocked(tool14, args) {
-  const patterns = BLOCKED_PATTERNS[tool14];
+function isBlocked(tool13, args) {
+  const patterns = BLOCKED_PATTERNS[tool13];
   if (!patterns)
     return null;
-  if (tool14 === "bash") {
+  if (tool13 === "bash") {
     const cmd = args.command;
     if (!cmd)
       return null;
@@ -2758,7 +2571,7 @@ function isBlocked(tool14, args) {
     }
     return null;
   }
-  if (tool14 === "read") {
+  if (tool13 === "read") {
     const filePath = args.filePath;
     if (!filePath)
       return null;
@@ -2769,7 +2582,7 @@ function isBlocked(tool14, args) {
     }
     return null;
   }
-  if (tool14 === "write") {
+  if (tool13 === "write") {
     const filePath = args.filePath;
     if (!filePath)
       return null;
@@ -2783,8 +2596,8 @@ function isBlocked(tool14, args) {
   return null;
 }
 function checkArchConstraint(directory, filePath) {
-  const constraintsPath = join19(codebaseDir(directory), "CONSTRAINTS.md");
-  if (!existsSync19(constraintsPath))
+  const constraintsPath = join18(codebaseDir(directory), "CONSTRAINTS.md");
+  if (!existsSync18(constraintsPath))
     return null;
   try {
     const content = readFileSync18(constraintsPath, "utf-8");
@@ -2828,7 +2641,7 @@ function isUiDesignApprovalRequired(directory) {
     return !(state.design_stage === "handoff_complete" && state.design_approved);
   }
   const planPath = phasePlanPath(directory, state.phase || 1);
-  if (!existsSync19(planPath))
+  if (!existsSync18(planPath))
     return false;
   const planContent = readFileSync18(planPath, "utf-8");
   if (!isUiHeavyTask(planContent))
@@ -2859,18 +2672,18 @@ async function toolGuardHook(ctx, input, output) {
 }
 
 // src/hooks/session-start.ts
-import { existsSync as existsSync20, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync19 } from "fs";
 async function sessionStartHook(ctx) {
   const planningDir2 = ctx.directory + "/.planning";
   const codebaseDirectory = codebaseDir(ctx.directory);
   const workspaceRoot = findWorkspaceRoot(ctx.directory);
   const config = workspaceRoot ? getWorkspaceConfig(ctx.directory) : null;
-  if (!existsSync20(planningDir2)) {
+  if (!existsSync19(planningDir2)) {
     return {
       flowdeck_phase: null,
       flowdeck_status: "no_plan",
       flowdeck_warning: "Run /fd-map-codebase to index the codebase, then /fd-new-feature to start a feature.",
-      flowdeck_has_codebase: existsSync20(codebaseDirectory),
+      flowdeck_has_codebase: existsSync19(codebaseDirectory),
       ...workspaceRoot && config?.sub_repos ? {
         flowdeck_workspace_root: workspaceRoot,
         flowdeck_sub_repos: config.sub_repos,
@@ -2889,7 +2702,7 @@ async function sessionStartHook(ctx) {
       flowdeck_status: currentPhase["status"] ?? null,
       flowdeck_steps_pending: currentPhase["steps_pending"] ?? null,
       flowdeck_last_action: currentPhase["last_action"] ?? null,
-      flowdeck_has_codebase: existsSync20(codebaseDirectory)
+      flowdeck_has_codebase: existsSync19(codebaseDirectory)
     };
     if (workspaceRoot && config?.sub_repos && config.sub_repos.length > 0) {
       result.flowdeck_workspace_root = workspaceRoot;
@@ -2903,7 +2716,7 @@ async function sessionStartHook(ctx) {
       flowdeck_phase: null,
       flowdeck_status: "error",
       flowdeck_warning: "State file unreadable. Continuing without flowdeck context.",
-      flowdeck_has_codebase: existsSync20(codebaseDirectory)
+      flowdeck_has_codebase: existsSync19(codebaseDirectory)
     };
     if (workspaceRoot && config?.sub_repos && config.sub_repos.length > 0) {
       result.flowdeck_workspace_root = workspaceRoot;
@@ -3035,13 +2848,13 @@ class NotificationController {
     return this.lastNotifiedKey;
   }
 }
-function notifyPermissionNeeded(tool14) {
-  notify("FlowDeck Permission Required", `Agent needs approval to use tool: ${tool14}`, "critical");
+function notifyPermissionNeeded(tool13) {
+  notify("FlowDeck Permission Required", `Agent needs approval to use tool: ${tool13}`, "critical");
 }
 
 // src/hooks/patch-trust.ts
-import { existsSync as existsSync21, readFileSync as readFileSync20 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync20 } from "fs";
+import { join as join19 } from "path";
 var HIGH_RISK_KEYWORDS = [
   "password",
   "secret",
@@ -3063,8 +2876,8 @@ var HIGH_RISK_KEYWORDS = [
   "privilege"
 ];
 function loadFailedPaths(directory) {
-  const p = join20(codebaseDir(directory), "FAILURES.json");
-  if (!existsSync21(p))
+  const p = join19(codebaseDir(directory), "FAILURES.json");
+  if (!existsSync20(p))
     return [];
   try {
     const data = JSON.parse(readFileSync20(p, "utf-8"));
@@ -3120,8 +2933,8 @@ async function patchTrustHook(ctx, input, output) {
 }
 
 // src/hooks/decision-trace-hook.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync11, appendFileSync as appendFileSync4 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync11, appendFileSync as appendFileSync4 } from "fs";
+import { join as join20 } from "path";
 async function decisionTraceHook(ctx, input, output) {
   if (input.tool !== "write" && input.tool !== "edit")
     return;
@@ -3130,7 +2943,7 @@ async function decisionTraceHook(ctx, input, output) {
     return;
   const base = codebaseDir(ctx.directory);
   try {
-    if (!existsSync22(base))
+    if (!existsSync21(base))
       mkdirSync11(base, { recursive: true });
     const entry = {
       timestamp: new Date().toISOString(),
@@ -3143,14 +2956,14 @@ async function decisionTraceHook(ctx, input, output) {
       risk_level: "unknown",
       auto_recorded: true
     };
-    appendFileSync4(join21(base, "DECISIONS.jsonl"), JSON.stringify(entry) + `
+    appendFileSync4(join20(base, "DECISIONS.jsonl"), JSON.stringify(entry) + `
 `, "utf-8");
   } catch {}
 }
 
 // src/services/approval-manager.ts
-import { existsSync as existsSync23, readFileSync as readFileSync21, writeFileSync as writeFileSync12, mkdirSync as mkdirSync12 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync21, writeFileSync as writeFileSync12, mkdirSync as mkdirSync12 } from "fs";
+import { join as join21 } from "path";
 var APPROVAL_TTL_MS = 30 * 60 * 1000;
 var SENSITIVE_PATTERNS = [
   /auth/i,
@@ -3187,11 +3000,11 @@ function isSensitivePath(filePath) {
   return SENSITIVE_PATTERNS.some((p) => p.test(filePath));
 }
 function approvalsPath(dir) {
-  return join22(codebaseDir(dir), "APPROVALS.json");
+  return join21(codebaseDir(dir), "APPROVALS.json");
 }
 function loadStore(dir) {
   const p = approvalsPath(dir);
-  if (!existsSync23(p))
+  if (!existsSync22(p))
     return { requests: [] };
   try {
     return JSON.parse(readFileSync21(p, "utf-8"));
@@ -3212,8 +3025,8 @@ async function approvalHook(context, toolInput, output) {
   if (!ENABLED2)
     return;
   const dir = context.directory ?? process.cwd();
-  const tool14 = toolInput.name ?? toolInput.tool ?? "";
-  if (!WRITE_TOOLS.has(tool14))
+  const tool13 = toolInput.name ?? toolInput.tool ?? "";
+  if (!WRITE_TOOLS.has(tool13))
     return;
   const args = output.args ?? {};
   const filePath = String(args.path ?? args.file_path ?? args.filename ?? "");
@@ -3230,8 +3043,8 @@ async function approvalHook(context, toolInput, output) {
 }
 
 // src/services/event-logger.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync13, appendFileSync as appendFileSync5, readFileSync as readFileSync22, writeFileSync as writeFileSync13, renameSync, unlinkSync, statSync } from "fs";
-import { join as join23, resolve as resolve2, sep } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync13, appendFileSync as appendFileSync5, readFileSync as readFileSync22, writeFileSync as writeFileSync13, renameSync, unlinkSync, statSync } from "fs";
+import { join as join22, resolve as resolve2, sep } from "path";
 var SENSITIVE_KEYS = [
   "password",
   "token",
@@ -3301,10 +3114,10 @@ function logEvent(directory, event, log) {
     lastPersistenceError = "Invalid directory";
     return false;
   }
-  const logDir = join23(directory, ".opencode");
-  const logPath = join23(logDir, "flowdeck-events.jsonl");
+  const logDir = join22(directory, ".opencode");
+  const logPath = join22(logDir, "flowdeck-events.jsonl");
   try {
-    if (!existsSync24(logDir)) {
+    if (!existsSync23(logDir)) {
       mkdirSync13(logDir, { recursive: true });
     }
     appendFileSync5(logPath, JSON.stringify(event) + `
@@ -3614,45 +3427,45 @@ function stableStringify(obj) {
   return `{${pairs.join(",")}}`;
 }
 function resolveEnvVars(command) {
-  return command.replace(/\$RTK_BIN\b/gi, "rtk").replace(/\$HOME\b/gi, "~").replace(/\$USER\b/gi, "user");
+  return command.replace(/\$HOME\b/gi, "~").replace(/\$USER\b/gi, "user");
 }
 function collapseWhitespace(input) {
   return input.replace(/\s+/g, " ").trim();
 }
 function normalizeAction(toolName, args) {
-  const tool14 = toolName.toLowerCase();
-  if (tool14 === "bash" || tool14 === "shell") {
+  const tool13 = toolName.toLowerCase();
+  if (tool13 === "bash" || tool13 === "shell") {
     const command = typeof args.command === "string" ? args.command : "";
     const normalized = collapseWhitespace(resolveEnvVars(command)).toLowerCase();
     return `shell:${normalized}`;
   }
-  if (tool14 === "read" || tool14 === "view") {
+  if (tool13 === "read" || tool13 === "view") {
     const filePath = typeof args.filePath === "string" ? args.filePath : "";
     try {
-      return `${tool14}:${resolve3(filePath || "")}`;
+      return `${tool13}:${resolve3(filePath || "")}`;
     } catch {
-      return `${tool14}:${filePath}`;
+      return `${tool13}:${filePath}`;
     }
   }
-  if (tool14 === "write" || tool14 === "edit") {
+  if (tool13 === "write" || tool13 === "edit") {
     const filePath = typeof args.filePath === "string" ? args.filePath : "";
     try {
-      return `${tool14}:${resolve3(filePath || "")}`;
+      return `${tool13}:${resolve3(filePath || "")}`;
     } catch {
-      return `${tool14}:${filePath}`;
+      return `${tool13}:${filePath}`;
     }
   }
-  if (tool14 === "grep" || tool14 === "glob" || tool14 === "search") {
+  if (tool13 === "grep" || tool13 === "glob" || tool13 === "search") {
     const pattern = typeof args.pattern === "string" ? args.pattern : "";
     const path = typeof args.path === "string" ? args.path : "";
-    return `${tool14}:${pattern}:${resolve3(path || ".")}`;
+    return `${tool13}:${pattern}:${resolve3(path || ".")}`;
   }
   const sorted = stableStringify(args);
-  return `${tool14}:${sorted}`;
+  return `${tool13}:${sorted}`;
 }
 function classifyObservation(toolName, previous, output, status, similarityThreshold) {
   const outputPreview = getOutputPreview(output);
-  const tool14 = toolName.toLowerCase();
+  const tool13 = toolName.toLowerCase();
   if (status === "blocked") {
     return { observation: "same_result", outputHash: hashOutput(output), outputPreview };
   }
@@ -3666,7 +3479,7 @@ function classifyObservation(toolName, previous, output, status, similarityThres
       outputPreview: errorMessage.slice(0, 200)
     };
   }
-  if (tool14 === "write" || tool14 === "edit") {
+  if (tool13 === "write" || tool13 === "edit") {
     const contentHash = hashOutput(output);
     return { observation: "new_information", outputHash: contentHash, outputPreview };
   }
@@ -3677,7 +3490,7 @@ function classifyObservation(toolName, previous, output, status, similarityThres
   if (outputHash === previous.outputHash) {
     return { observation: "same_result", outputHash, outputPreview };
   }
-  if (NON_MUTATING_TOOLS.has(tool14)) {
+  if (NON_MUTATING_TOOLS.has(tool13)) {
     const similarity = lineSimilarity(outputPreview, previous.outputPreview);
     if (similarity >= similarityThreshold) {
       return { observation: "no_progress", outputHash, outputPreview };
@@ -3686,25 +3499,25 @@ function classifyObservation(toolName, previous, output, status, similarityThres
   return { observation: "new_information", outputHash, outputPreview };
 }
 function redactForDisplay(toolName, normalizedKey) {
-  const tool14 = toolName.toLowerCase();
-  if (tool14 === "bash" || tool14 === "shell") {
+  const tool13 = toolName.toLowerCase();
+  if (tool13 === "bash" || tool13 === "shell") {
     const idx2 = normalizedKey.indexOf(":");
     const cmd = idx2 >= 0 ? normalizedKey.slice(idx2 + 1) : normalizedKey;
     const preview = cmd.slice(0, 30);
     const hash = djb2Hash(cmd);
-    return `${tool14}:"${preview}" (hash: ${hash})`;
+    return `${tool13}:"${preview}" (hash: ${hash})`;
   }
   const idx = normalizedKey.indexOf(":");
   if (idx >= 0) {
     const body = normalizedKey.slice(idx + 1);
     if (body.startsWith("/") || body.startsWith(".") || body.includes("/")) {
-      return `${tool14}:"${body}"`;
+      return `${tool13}:"${body}"`;
     }
     const preview = body.slice(0, 30);
     const hash = djb2Hash(body);
-    return `${tool14}:"${preview}" (hash: ${hash})`;
+    return `${tool13}:"${preview}" (hash: ${hash})`;
   }
-  return `${tool14}:"${normalizedKey}"`;
+  return `${tool13}:"${normalizedKey}"`;
 }
 
 class LoopDetector {
@@ -3904,8 +3717,8 @@ function createContextWindowMonitorHook() {
 }
 
 // src/hooks/shell-env-hook.ts
-import { existsSync as existsSync25, readFileSync as readFileSync23 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync23 } from "fs";
+import { join as join23 } from "path";
 import { createRequire } from "module";
 var _version;
 function getVersion() {
@@ -3941,7 +3754,7 @@ var MARKER_TO_LANG = {
 };
 function detectPackageManager(root) {
   for (const [lockfile, pm] of Object.entries(LOCKFILE_TO_PM)) {
-    if (existsSync25(join24(root, lockfile)))
+    if (existsSync24(join23(root, lockfile)))
       return pm;
   }
   return;
@@ -3950,7 +3763,7 @@ function detectLanguages(root) {
   const langs = [];
   const seen = new Set;
   for (const [marker, lang] of Object.entries(MARKER_TO_LANG)) {
-    if (!seen.has(lang) && existsSync25(join24(root, marker))) {
+    if (!seen.has(lang) && existsSync24(join23(root, marker))) {
       langs.push(lang);
       seen.add(lang);
     }
@@ -3958,8 +3771,8 @@ function detectLanguages(root) {
   return langs;
 }
 function readCurrentPhase(root) {
-  const statePath3 = join24(root, ".planning", "STATE.md");
-  if (!existsSync25(statePath3))
+  const statePath3 = join23(root, ".planning", "STATE.md");
+  if (!existsSync24(statePath3))
     return;
   try {
     const content = readFileSync23(statePath3, "utf-8");
@@ -3969,18 +3782,6 @@ function readCurrentPhase(root) {
     return;
   }
 }
-var _rtkDetection;
-function getRtkDetection() {
-  if (_rtkDetection !== undefined)
-    return _rtkDetection;
-  try {
-    const det = detectRtk();
-    _rtkDetection = { installed: det.installed, binPath: det.binPath };
-  } catch {
-    _rtkDetection = { installed: false };
-  }
-  return _rtkDetection;
-}
 function createShellEnvHook(ctx) {
   const root = ctx.worktree || ctx.directory;
   return async (_input, output) => {
@@ -3998,14 +3799,6 @@ function createShellEnvHook(ctx) {
     const phase = readCurrentPhase(root);
     if (phase)
       output.env.FLOWDECK_PHASE = phase;
-    const rtk = getRtkDetection();
-    output.env.RTK_INSTALLED = rtk.installed ? "true" : "false";
-    if (rtk.installed && rtk.binPath) {
-      output.env.RTK_BIN = rtk.binPath;
-    }
-    if (rtk.installed) {
-      output.env.RTK_TELEMETRY_DISABLED = "1";
-    }
   };
 }
 
@@ -4087,8 +3880,8 @@ function createSessionIdleHook(client, tracker) {
 }
 
 // src/hooks/compaction-hook.ts
-import { existsSync as existsSync26, readFileSync as readFileSync24 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync24 } from "fs";
+import { join as join24 } from "path";
 var STRUCTURED_SUMMARY_PROMPT = `
 When summarizing this session, you MUST include the following sections:
 
@@ -4129,7 +3922,7 @@ For each: agent name, status, description, session_id.
 var _lastInjected = new Map;
 function readPlanningState2(directory) {
   const sp = statePath(directory);
-  if (!existsSync26(sp))
+  if (!existsSync25(sp))
     return null;
   try {
     const content = readFileSync24(sp, "utf-8");
@@ -4161,15 +3954,15 @@ function createCompactionHook(ctx, tracker) {
       sections.push(`_State unchanged since last compaction. summaryVersion=${currentStateVersion}_`);
       sections.push("");
     }
-    const indexPath2 = join25(ctx.directory, ".planning", "CODEBASE_INDEX.md");
-    if (indexChanged && existsSync26(indexPath2)) {
+    const indexPath2 = join24(ctx.directory, ".planning", "CODEBASE_INDEX.md");
+    if (indexChanged && existsSync25(indexPath2)) {
       try {
         const indexContent = readFileSync24(indexPath2, "utf-8");
         const indexSummary = "\n## Codebase Index\n```\n" + indexContent.slice(0, 800) + "\n```\n";
         sections.push(indexSummary);
         sections.push("");
       } catch {}
-    } else if (existsSync26(indexPath2)) {
+    } else if (existsSync25(indexPath2)) {
       sections.push(`## Codebase Index (unchanged, v${currentIndexVersion})`);
       sections.push(`_Index unchanged since last compaction. summaryVersion=${currentIndexVersion}_`);
       sections.push("");
@@ -4250,7 +4043,6 @@ var ALWAYS_ALLOWED = new Set([
   "load-rules",
   "list-rules",
   "council",
-  "rtk-setup",
   "hash-edit",
   "failure-replay"
 ]);
@@ -4288,7 +4080,7 @@ function blockMessage(toolName) {
 ` + `  @tester            — tests, builds, and shell-heavy verification
 ` + `  @writer            — documentation writing
 
-` + `Allowed tools for orchestrator: read, search, planning-state, codebase-state, repo-memory, decision-trace, policy-engine, reflect, codegraph, load-rules, council, rtk-setup, hash-edit, failure-replay.
+` + `Allowed tools for orchestrator: read, search, planning-state, codebase-state, repo-memory, decision-trace, policy-engine, reflect, codegraph, load-rules, council, hash-edit, failure-replay.
 
 ` + `To disable this guard: set FLOWDECK_ORCHESTRATOR_GUARD=off`;
 }
@@ -4403,14 +4195,14 @@ async function runAutoLearner(client, directory, appLog) {
 }
 
 // src/mcp/index.ts
-import { spawnSync as spawnSync4 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 function getDisabledMcps() {
   const raw = process.env.FLOWDECK_DISABLE_MCP ?? "";
   return new Set(raw.split(",").map((s) => s.trim()).filter(Boolean));
 }
 function isLauncherAvailable(launcher) {
   try {
-    const result = spawnSync4(launcher, ["--version"], {
+    const result = spawnSync3(launcher, ["--version"], {
       encoding: "utf-8",
       timeout: 5000,
       stdio: "pipe"
@@ -7759,8 +7551,8 @@ function getAgentConfigs(agentModels) {
 // src/index.ts
 function lazyLoadRulePaths(projectRoot) {
   const __dir = dirname3(fileURLToPath2(import.meta.url));
-  const rulesDir = join26(__dir, "..", "src", "rules");
-  if (!existsSync27(rulesDir))
+  const rulesDir = join25(__dir, "..", "src", "rules");
+  if (!existsSync26(rulesDir))
     return { paths: [], diagnostics: "[LazyRuleLoader] rules directory not found" };
   const detectedLanguages = detectProjectLanguages(projectRoot);
   const paths = getStartupRulePaths(rulesDir, detectedLanguages);
@@ -7770,8 +7562,8 @@ function lazyLoadRulePaths(projectRoot) {
 }
 function loadCommands() {
   const __dir = dirname3(fileURLToPath2(import.meta.url));
-  const commandsDir = join26(__dir, "..", "src", "commands");
-  if (!existsSync27(commandsDir))
+  const commandsDir = join25(__dir, "..", "src", "commands");
+  if (!existsSync26(commandsDir))
     return {};
   const commands = {};
   try {
@@ -7779,7 +7571,7 @@ function loadCommands() {
       if (!file.endsWith(".md"))
         continue;
       const name = basename2(file, ".md");
-      const raw = readFileSync25(join26(commandsDir, file), "utf-8");
+      const raw = readFileSync25(join25(commandsDir, file), "utf-8");
       let description;
       let template = raw;
       const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
@@ -7872,8 +7664,8 @@ var plugin = async (input, _options) => {
           }
         }
       }
-      const skillsDir = join26(dirname3(fileURLToPath2(import.meta.url)), "..", "src", "skills");
-      if (existsSync27(skillsDir)) {
+      const skillsDir = join25(dirname3(fileURLToPath2(import.meta.url)), "..", "src", "skills");
+      if (existsSync26(skillsDir)) {
         const cfgAny = cfg;
         if (!cfgAny.skills || typeof cfgAny.skills !== "object") {
           cfgAny.skills = { paths: [] };
@@ -7912,7 +7704,6 @@ var plugin = async (input, _options) => {
       codegraph: codegraphTool,
       "load-rules": loadRulesTool,
       "list-rules": listRulesTool,
-      "rtk-setup": rtkSetupTool,
       "merge-assist": mergeAssistTool
     },
     "shell.env": shellEnvHook,