@k-leumas/queque-cli 0.4.2 → 0.5.0

package/dist/cli/main.js

@@ -1,1761 +1,47 @@
 #!/usr/bin/env node
+import { createRequire as __quequeCreateRequire } from 'node:module';
+const require = __quequeCreateRequire(import.meta.url);
 
-// src/cli/main.ts
-import * as fs2 from "fs";
-import { cac } from "cac";
-
-// src/context/providers/filesystem-context.ts
-var FILENAME_RE = /\b[\w.-]+\.\w{2,6}\b/g;
-var filesystemContextProvider = {
-  id: "filesystem-context",
-  intents: ["filesystem"],
-  async gather(input) {
-    const match = input.base.queryText.match(FILENAME_RE);
-    return {
-      kind: "filesystem",
-      payload: {
-        cwd: input.base.cwd,
-        apparentFilename: match?.[0] ?? null
-      }
-    };
-  }
-};
-
-// src/context/providers/git-context.ts
-import { execFile as execFile2 } from "child_process";
-import { statSync } from "fs";
-import { promisify as promisify2 } from "util";
-
-// src/shared/debug-log.ts
-import * as fsp from "fs/promises";
-
-// src/shared/qq-config.ts
-import { readFileSync } from "fs";
+// src/cli/launcher.ts
+import { lstatSync, mkdirSync } from "fs";
+import * as nodeModule from "module";
 import { homedir } from "os";
-import { join } from "path";
-import { z } from "zod";
-var DEFAULT_SENSITIVE_PATH_PATTERNS = [
-  "\\.env",
-  "credentials",
-  "\\.pem$",
-  "id_rsa",
-  "\\.ssh/",
-  "\\.aws/",
-  "secret"
-];
-var DEFAULT_REDACT_LOG_KEYS = ["lbuffer", "rbuffer", "queryText", "request"];
-var DEFAULT_DESTRUCTIVE_COMMAND_PATTERNS = [
-  "\\brm\\s+(-?-?\\w+)?\\b",
-  "\\bsudo\\b",
-  "\\bchmod\\s+-R\\b",
-  ">\\s*/dev/",
-  "\\bcurl\\b[^\\n|]*\\|\\s*sh\\b",
-  "\\bwget\\b[^\\n|]*\\|\\s*sh\\b"
-];
-var privacyConfigSchema = z.object({
-  sensitivePathPatterns: z.array(z.string()).optional(),
-  redactLogKeys: z.array(z.string()).optional(),
-  allowFileRead: z.boolean().optional(),
-  useGitignore: z.boolean().optional().describe(
-    "Not yet implemented \u2014 this config option will enable gitignore-based filtering in the future. Placeholder only."
-  )
-}).optional();
-var safetyConfigSchema = z.object({
-  destructiveCommandPatterns: z.array(z.string()).optional()
-}).optional();
-var qqConfigFileSchema = z.object({
-  privacy: privacyConfigSchema,
-  safety: safetyConfigSchema
-});
-var cachedConfig = null;
-function defaultConfigPath() {
-  return process.env.QQ_CONFIG_FILE ?? join(homedir(), ".config", "qq", "config.json");
-}
-var MAX_PATTERN_LENGTH = 256;
-function compilePatterns(patterns) {
-  const compiled = [];
-  for (const source of patterns) {
-    if (source.length > MAX_PATTERN_LENGTH) {
-      continue;
-    }
-    try {
-      compiled.push(new RegExp(source, "i"));
-    } catch {
-    }
-  }
-  return compiled;
-}
-function envFlagEnabled(name) {
-  const value = process.env[name];
-  return value === "1" || value === "true";
-}
-function readConfigFile() {
-  const configPath = defaultConfigPath();
-  let raw;
-  try {
-    raw = readFileSync(configPath, "utf8");
-  } catch (error) {
-    const code = error.code;
-    if (code === "ENOENT") {
-      return {};
-    }
-    return {};
-  }
-  try {
-    return qqConfigFileSchema.parse(JSON.parse(raw));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.warn(`queque: ignoring invalid config at ${configPath}: ${message}`);
-    return {};
-  }
-}
-function loadQqConfig() {
-  if (cachedConfig) {
-    return cachedConfig;
-  }
-  const file = readConfigFile();
-  const sensitivePatterns = [
-    ...DEFAULT_SENSITIVE_PATH_PATTERNS,
-    ...file.privacy?.sensitivePathPatterns ?? []
-  ];
-  const redactKeys = [...DEFAULT_REDACT_LOG_KEYS, ...file.privacy?.redactLogKeys ?? []];
-  const destructivePatterns = [
-    ...DEFAULT_DESTRUCTIVE_COMMAND_PATTERNS,
-    ...file.safety?.destructiveCommandPatterns ?? []
-  ];
-  const allowFileRead = envFlagEnabled("QQ_ALLOW_FILE_READ") || (file.privacy?.allowFileRead ?? false);
-  cachedConfig = {
-    sensitivePathRegexes: compilePatterns(sensitivePatterns),
-    redactLogKeys: new Set(redactKeys),
-    allowFileRead,
-    destructiveCommandRegexes: compilePatterns(destructivePatterns)
-  };
-  return cachedConfig;
-}
-
-// src/shared/privacy-filter.ts
-function isSensitivePath(path2) {
-  const { sensitivePathRegexes } = loadQqConfig();
-  return sensitivePathRegexes.some((pattern) => pattern.test(path2));
-}
-function filterContextEnvelope(envelope) {
-  return {
-    ...envelope,
-    extras: envelope.extras.map((chunk) => {
-      if (chunk.kind !== "git") {
-        return chunk;
-      }
-      return {
-        ...chunk,
-        payload: {
-          ...chunk.payload,
-          changedFiles: chunk.payload.changedFiles.filter((filePath) => !isSensitivePath(filePath))
-        }
-      };
-    })
-  };
-}
-function redactForLog(details) {
-  if (process.env.QQ_DEBUG_VERBOSE === "1" || details === void 0) {
-    return details;
-  }
-  if (details === null || typeof details !== "object") {
-    return details;
-  }
-  if (Array.isArray(details)) {
-    return details.map((item) => redactForLog(item));
-  }
-  const { redactLogKeys } = loadQqConfig();
-  const input = details;
-  const output = {};
-  for (const [key, value] of Object.entries(input)) {
-    if (redactLogKeys.has(key)) {
-      if (typeof value === "string") {
-        output[key] = `[redacted:${value.length}chars]`;
-      } else {
-        output[key] = redactForLog(value);
-      }
-      continue;
-    }
-    output[key] = redactForLog(value);
-  }
-  return output;
-}
-function isDestructiveCommand(command) {
-  const { destructiveCommandRegexes } = loadQqConfig();
-  return destructiveCommandRegexes.some((pattern) => pattern.test(command));
-}
-
-// src/shared/debug-log.ts
-var debugLogPath = process.env.QQ_DEBUG_LOG_FILE ?? `/tmp/qq-${process.getuid?.() ?? "unknown"}-debug.log`;
-function formatDetails(details) {
-  if (details === void 0) return "";
-  try {
-    return ` ${JSON.stringify(details)}`;
-  } catch {
-    return " [unserializable-details]";
-  }
-}
-async function appendDebugLog(scope, message, details) {
-  const line = `${(/* @__PURE__ */ new Date()).toISOString()} [${scope}] ${message}${formatDetails(redactForLog(details))}
-`;
-  try {
-    await fsp.appendFile(debugLogPath, line, { encoding: "utf-8", mode: 384 });
-  } catch {
-  }
-}
-
-// src/shared/vcs-context.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-async function runGit(cwd, args) {
-  try {
-    const { stdout } = await execFileAsync("git", ["-C", cwd, ...args], { encoding: "utf8" });
-    return stdout.trim();
-  } catch {
-    return null;
-  }
-}
-async function detectVcsContext(cwd) {
-  const insideWorkTree = await runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
-  if (insideWorkTree !== "true") {
-    return { kind: "none", cwd };
-  }
-  const root = await runGit(cwd, ["rev-parse", "--show-toplevel"]) ?? cwd;
-  const branch = await runGit(cwd, ["branch", "--show-current"]) || null;
-  const dirty = Boolean((await runGit(cwd, ["status", "--porcelain=v1"]))?.length);
-  return {
-    kind: "git",
-    cwd,
-    root,
-    branch,
-    dirty
-  };
-}
-
-// src/context/providers/git-context.ts
-var execFileAsync2 = promisify2(execFile2);
-var GIT_TIMEOUT_MS = 5e3;
-function assertSafeCwd(cwd) {
-  let st;
-  try {
-    st = statSync(cwd);
-  } catch {
-    throw new Error(`cwd not accessible: ${cwd}`);
-  }
-  if (!st.isDirectory()) throw new Error(`cwd is not a directory: ${cwd}`);
-}
-function unescapeGitPath(s) {
-  return s.replace(/\\([0-7]{3})/g, (_, oct) => String.fromCodePoint(parseInt(oct, 8))).replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\\\/g, "\\");
-}
-function stripQuotes(value) {
-  if (value.startsWith('"') && value.endsWith('"')) {
-    return unescapeGitPath(value.slice(1, -1));
-  }
-  return value;
-}
-function parsePorcelainLine(line) {
-  if (line.length < 4) {
-    return null;
-  }
-  const rest = line.slice(3);
-  const renameSeparator = " -> ";
-  const renameIndex = rest.indexOf(renameSeparator);
-  if (renameIndex !== -1) {
-    return stripQuotes(rest.slice(renameIndex + renameSeparator.length));
-  }
-  return stripQuotes(rest);
-}
-async function getChangedFiles(cwd) {
-  try {
-    assertSafeCwd(cwd);
-    const { stdout } = await execFileAsync2("git", ["-C", cwd, "status", "--porcelain"], {
-      encoding: "utf8",
-      timeout: GIT_TIMEOUT_MS
-    });
-    return stdout.split("\n").filter(Boolean).map(parsePorcelainLine).filter((path2) => path2 !== null);
-  } catch {
-    return [];
-  }
-}
-var gitContextProvider = {
-  id: "git-context",
-  intents: ["codebase", "shell-command"],
-  async gather(input) {
-    if (input.decision.intent === "shell-command" && !input.decision.signals.includes("git-prefix")) {
-      return null;
-    }
-    try {
-      const vcs = await detectVcsContext(input.base.cwd);
-      if (vcs.kind === "none") {
-        return null;
-      }
-      const changedFiles = await getChangedFiles(input.base.cwd);
-      void appendDebugLog("context", "git provider gathered", {
-        cwd: input.base.cwd,
-        branch: vcs.branch,
-        dirty: vcs.dirty,
-        changedFiles: changedFiles.length
-      });
-      return {
-        kind: "git",
-        payload: {
-          cwd: vcs.cwd,
-          root: vcs.root,
-          branch: vcs.branch,
-          dirty: vcs.dirty,
-          changedFiles
-        }
-      };
-    } catch (error) {
-      void appendDebugLog("context", "git provider failed", {
-        cwd: input.base.cwd,
-        message: error instanceof Error ? error.message : String(error)
-      });
-      return null;
-    }
-  }
-};
-
-// src/providers/claude.ts
-import Anthropic from "@anthropic-ai/sdk";
-
-// src/contracts/candidates.ts
-import { z as z2 } from "zod";
-var commandCandidateSchema = z2.object({
-  command: z2.string().trim().min(1),
-  explanation: z2.string()
-});
-var candidateListSchema = z2.array(commandCandidateSchema).min(1).max(5);
-
-// src/shared/env-file.ts
-import { existsSync, readFileSync as readFileSync2 } from "fs";
-import { dirname, join as join2 } from "path";
-function findUp(startDir, filename) {
-  let current = startDir;
-  while (true) {
-    const candidate = join2(current, filename);
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-    const parent = dirname(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-}
-function parseEnvFile(content) {
-  const values = /* @__PURE__ */ new Map();
-  for (const rawLine of content.split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("#")) {
-      continue;
-    }
-    const match = line.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
-    if (!match) {
-      continue;
-    }
-    const [, key, rawValue] = match;
-    let value = rawValue.trim();
-    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-      value = value.slice(1, -1);
-    }
-    values.set(key, value);
-  }
-  return values;
-}
-var envCache = /* @__PURE__ */ new Map();
-function readEnvValueFromDotEnvLocal(key, startDir = process.cwd()) {
-  const cacheKey = `${key}\0${startDir}`;
-  if (envCache.has(cacheKey)) {
-    return envCache.get(cacheKey) ?? null;
-  }
-  const envPath = findUp(startDir, ".env.local");
-  if (!envPath) {
-    envCache.set(cacheKey, null);
-    return null;
-  }
-  const values = parseEnvFile(readFileSync2(envPath, "utf8"));
-  const result = values.get(key) ?? null;
-  envCache.set(cacheKey, result);
-  return result;
-}
-
-// src/providers/claude.ts
-var DEFAULT_MODEL = "claude-sonnet-5";
-function resolveModel() {
-  return process.env.QQ_MODEL ?? readEnvValueFromDotEnvLocal("QQ_MODEL") ?? DEFAULT_MODEL;
-}
-function extractText(content) {
-  return content.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text ?? "").join("").trim();
+import { isAbsolute, join } from "path";
+var SHARED_WRITE_BITS = 18;
+function isPrivateDirectory(path, uid) {
+  const stats = lstatSync(path);
+  return stats.isDirectory() && !stats.isSymbolicLink() && stats.uid === uid && (stats.mode & SHARED_WRITE_BITS) === 0;
 }
-function stripCodeFence(raw) {
-  const m = raw.trim().match(/^```(?:json)?\s*\n?([\s\S]*?)\n?```\s*$/);
-  return m ? m[1].trim() : raw.trim();
-}
-function parseCandidates(text) {
-  let parsed;
-  try {
-    parsed = JSON.parse(stripCodeFence(text));
-  } catch {
-    const trimmed = text.trim();
-    return [{ command: trimmed || 'echo ""', explanation: "" }];
-  }
-  try {
-    return candidateListSchema.parse(parsed);
-  } catch {
-    return [{ command: 'echo ""', explanation: "QueQue: unexpected response format" }];
-  }
-}
-function shouldForceSelector() {
-  const configured = process.env.QQ_FORCE_SELECTOR ?? readEnvValueFromDotEnvLocal("QQ_FORCE_SELECTOR");
-  return configured === "1" || configured === "true";
-}
-function ensureSelectableCandidates(candidates) {
-  if (!shouldForceSelector() || candidates.length >= 2) {
-    return candidates;
-  }
-  const [first] = candidates;
-  return [
-    first,
-    {
-      command: first.command,
-      explanation: first.explanation.length > 0 ? `${first.explanation} (forced duplicate for selector testing)` : "Forced duplicate for selector testing."
-    }
-  ];
-}
-function buildPrompt(envelope) {
-  const filtered = filterContextEnvelope(envelope);
-  const gitChunk = filtered.extras.find((chunk) => chunk.kind === "git");
-  const filesystemChunk = filtered.extras.find((chunk) => chunk.kind === "filesystem");
-  return [
-    "Return ONLY a JSON array of 1-3 shell command candidates, most likely first.",
-    'Each item must have exactly these keys: "command" and "explanation".',
-    "No markdown, no prose, no code fences. Raw JSON array only.",
-    "",
-    "The command should be safe to place back into a shell buffer.",
-    "",
-    "Shell context:",
-    JSON.stringify(
-      {
-        cwd: filtered.base.cwd,
-        queryText: filtered.base.queryText,
-        platform: filtered.base.platform,
-        shellName: filtered.base.shellName,
-        ...gitChunk ? { versionControl: gitChunk.payload } : {},
-        ...filesystemChunk ? { filesystem: filesystemChunk.payload } : {}
-      },
-      null,
-      2
-    )
-  ].join("\n");
-}
-async function fetchCandidates(envelope, rbuffer = "") {
-  const apiKey = process.env.ANTHROPIC_API_KEY ?? readEnvValueFromDotEnvLocal("ANTHROPIC_API_KEY");
-  if (!apiKey) {
-    throw new Error("ANTHROPIC_API_KEY is required in the environment or .env.local");
-  }
-  const client = new Anthropic({ apiKey });
-  const prompt = buildPrompt(envelope);
-  const model = resolveModel();
-  void appendDebugLog("provider", "request start", {
-    model,
-    cwd: envelope.base.cwd,
-    rbufferLength: rbuffer.length,
-    extras: envelope.extras.map((chunk) => chunk.kind)
-  });
+function enablePerUserCompileCache() {
   try {
-    const response = await client.messages.create(
-      {
-        model,
-        max_tokens: 1024,
-        system: "You are QueQue, a terminal shell assistant. Return ONLY a JSON array of command candidates, ranked with the most correct/direct command first. No prose, no markdown, no code fences. When a command requires a value the user must supply (hostname, filename, branch name, etc.), wrap it in angle brackets: <placeholder>. Use descriptive names like <user@host>, <filename>, <branch-name>. Do not use angle brackets for optional flags or known values.",
-        messages: [{ role: "user", content: prompt }]
-      },
-      {
-        timeout: 25e3
-        // 25s — slightly under the zsh 30s FIFO timeout
-      }
-    );
-    const text = extractText(response.content);
-    const candidates = ensureSelectableCandidates(parseCandidates(text));
-    void appendDebugLog("provider", "response parsed", {
-      model,
-      candidateCount: candidates.length,
-      forceSelector: shouldForceSelector()
-    });
-    return candidates;
-  } catch (error) {
-    void appendDebugLog("provider", "request failed", {
-      model,
-      message: error instanceof Error ? error.message : String(error)
-    });
-    throw error;
-  }
-}
-var claudeAdapter = {
-  fetchCandidates
-};
-
-// src/registry/context-providers.ts
-var registry = /* @__PURE__ */ new Map();
-function registerContextProvider(descriptor) {
-  if (registry.has(descriptor.id)) {
-    throw new Error(`Context provider already registered: "${descriptor.id}"`);
-  }
-  registry.set(descriptor.id, descriptor);
-}
-function listContextProviders() {
-  return Array.from(registry.values());
-}
-
-// src/registry/provider-backends.ts
-var registry2 = /* @__PURE__ */ new Map();
-function registerProviderBackend(registration) {
-  if (registry2.has(registration.id)) {
-    throw new Error(`Provider backend already registered: "${registration.id}"`);
-  }
-  registry2.set(registration.id, registration);
-}
-function getProviderAdapter(id) {
-  return registry2.get(id)?.adapter;
-}
-
-// src/registry/shell-adapters.ts
-var registry3 = /* @__PURE__ */ new Map();
-function registerShellAdapter(descriptor) {
-  if (registry3.has(descriptor.id)) {
-    throw new Error(`Shell adapter already registered: "${descriptor.id}"`);
-  }
-  registry3.set(descriptor.id, descriptor);
-}
-function listShellAdapters() {
-  return Array.from(registry3.values());
-}
-
-// src/registry/storage-hooks.ts
-var registry4 = /* @__PURE__ */ new Map();
-function registerStorageHook(descriptor) {
-  if (registry4.has(descriptor.id)) {
-    throw new Error(`Storage hook already registered: "${descriptor.id}"`);
-  }
-  registry4.set(descriptor.id, descriptor);
-}
-
-// src/registry/bootstrap.ts
-var bootstrapped = false;
-function bootstrapBuiltins() {
-  if (bootstrapped) {
-    return;
-  }
-  bootstrapped = true;
-  registerContextProvider(gitContextProvider);
-  registerContextProvider(filesystemContextProvider);
-  registerShellAdapter({
-    id: "zsh",
-    shell: "zsh",
-    description: "zsh ZLE widget adapter (Phase 2 built-in)"
-  });
-  registerStorageHook({
-    id: "noop",
-    description: "No-op storage hook (default \u2014 no persistence)"
-  });
-  registerStorageHook({
-    id: "memory",
-    description: "In-memory storage hook (test and ephemeral use)"
-  });
-  registerProviderBackend({
-    id: "claude",
-    name: "Claude (Anthropic)",
-    description: "Anthropic Claude adapter \u2014 default LLM backend",
-    adapter: claudeAdapter
-  });
-}
-
-// src/client/run-foreground.ts
-import * as fsp4 from "fs/promises";
-import * as tty from "tty";
-import { render } from "ink";
-import React from "react";
-
-// src/contracts/request.ts
-import { z as z4 } from "zod";
-
-// src/contracts/shell.ts
-import { z as z3 } from "zod";
-var shellRequestSchema = z3.object({
-  version: z3.literal(1),
-  ttyPath: z3.string(),
-  cwd: z3.string().regex(/^\/[^\0]*$/, "cwd must be an absolute POSIX path"),
-  shellPid: z3.number().int().positive(),
-  lbuffer: z3.string(),
-  rbuffer: z3.string()
-});
-var shellResultSchema = z3.discriminatedUnion("kind", [
-  z3.object({
-    kind: z3.literal("cancel")
-  }).strict(),
-  z3.object({
-    kind: z3.literal("replace-buffer"),
-    lbuffer: z3.string(),
-    rbuffer: z3.string(),
-    query: z3.string().optional()
-  }),
-  z3.object({
-    kind: z3.literal("error"),
-    message: z3.string()
-  })
-]);
-
-// src/contracts/request.ts
-var requestIntentSchema = z4.enum([
-  "shell-command",
-  "codebase",
-  "filesystem",
-  "general",
-  "unknown"
-]);
-var normalizedRequestSchema = shellRequestSchema.extend({
-  intent: requestIntentSchema,
-  confidence: z4.number().min(0).max(1)
-});
-var baseContextSchema = z4.object({
-  queryText: z4.string(),
-  cwd: z4.string(),
-  ttyPath: z4.string(),
-  shellPid: z4.number().int().positive(),
-  /** Hardcoded 'zsh' for Phase 2 — cross-shell support is v2 scope. */
-  shellName: z4.literal("zsh"),
-  platform: z4.string(),
-  timestamp: z4.string()
-});
-var intentDecisionSchema = z4.object({
-  intent: requestIntentSchema,
-  confidence: z4.number().min(0).max(1),
-  signals: z4.array(z4.string())
-});
-var contextChunkSchema = z4.discriminatedUnion("kind", [
-  z4.object({
-    kind: z4.literal("git"),
-    payload: z4.object({
-      cwd: z4.string(),
-      root: z4.string(),
-      branch: z4.string().nullable(),
-      dirty: z4.boolean(),
-      /** File paths only (from git status --porcelain). No diff content, no file bytes. */
-      changedFiles: z4.array(z4.string())
-    })
-  }),
-  z4.object({
-    kind: z4.literal("filesystem"),
-    payload: z4.object({
-      cwd: z4.string(),
-      /** Apparent filename extracted from query text. No file bytes read. */
-      apparentFilename: z4.string().nullable()
-    })
-  })
-]);
-var contextEnvelopeSchema = z4.object({
-  base: baseContextSchema,
-  extras: z4.array(contextChunkSchema)
-});
-
-// src/intent/router.ts
-var GIT_PREFIX_RE = /^git\s/;
-var PKG_MANAGER_RE = /^(npm|pnpm|yarn)\s+(test|build|lint|run|start|dev|check|format|typecheck)\b/i;
-var FILESYSTEM_KEYWORDS_RE = /\b(?:rename|move(?:\s+file)?|find\s+files?|copy|delete|list\s+files?|image|folder|directory)\b/i;
-var SHELL_COMMAND_RE = /^(ls|echo|grep|awk|sed|curl|wget|ssh|cat|head|tail|cd|pwd|mkdir|touch|chmod|cp|mv|rm|which|man|ps|kill|sudo|command)\s|\|/;
-var FILE_PATH_RE = /(?:\/|\.\/|~\/|\.[a-zA-Z][\w-]*(?:\.\w+)?(?=\s|$)|\b[\w-]+\.(?:ts|tsx|js|jsx|mjs|cjs|py|go|rs|rb|java|sh|md|json|yaml|yml|toml|env|html|css|scss|txt|xml|svg|png|jpg|jpeg|gif|pdf|zip|tar|gz|lock|config)(?:\b|$))/;
-function classifyIntent(request) {
-  const query = request.lbuffer.trim();
-  if (query.length === 0) {
-    return {
-      intent: requestIntentSchema.enum.unknown,
-      confidence: 1,
-      signals: ["empty-query"]
-    };
-  }
-  if (GIT_PREFIX_RE.test(query)) {
-    return {
-      intent: requestIntentSchema.enum["shell-command"],
-      confidence: 1,
-      signals: ["git-prefix"]
-    };
-  }
-  if (PKG_MANAGER_RE.test(query)) {
-    return {
-      intent: requestIntentSchema.enum.codebase,
-      confidence: 1,
-      signals: ["pkg-manager-script"]
-    };
-  }
-  if (FILESYSTEM_KEYWORDS_RE.test(query)) {
-    return {
-      intent: requestIntentSchema.enum.filesystem,
-      confidence: 0.85,
-      signals: ["filesystem-keyword"]
-    };
-  }
-  if (SHELL_COMMAND_RE.test(query)) {
-    return {
-      intent: requestIntentSchema.enum["shell-command"],
-      confidence: 0.8,
-      signals: ["shell-command-signal"]
-    };
-  }
-  if (FILE_PATH_RE.test(query)) {
-    return {
-      intent: requestIntentSchema.enum.codebase,
-      confidence: 0.9,
-      signals: ["file-path-signal"]
-    };
-  }
-  return {
-    intent: requestIntentSchema.enum.general,
-    confidence: 0.5,
-    signals: ["no-strong-signal"]
-  };
-}
-
-// src/context/base-context.ts
-function buildBaseContext(request) {
-  return {
-    queryText: request.lbuffer.trim(),
-    cwd: request.cwd,
-    ttyPath: request.ttyPath,
-    shellPid: request.shellPid,
-    shellName: "zsh",
-    platform: process.platform,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-
-// src/context/pipeline.ts
-async function gatherContext(request) {
-  void appendDebugLog("context", "pipeline start", {
-    queryLength: request.lbuffer.length,
-    intent: request.intent
-  });
-  const base = buildBaseContext(request);
-  const decision = classifyIntent(request);
-  void appendDebugLog("context", "intent decision", {
-    intent: decision.intent,
-    signals: decision.signals
-  });
-  const extras = [];
-  const providers = listContextProviders();
-  for (const provider of providers) {
-    const supportsAllIntents = provider.intents.includes("*");
-    const supportsIntent = provider.intents.includes(decision.intent);
-    if (!supportsAllIntents && !supportsIntent) {
-      continue;
-    }
-    try {
-      const chunk = await provider.gather({ base, decision });
-      if (chunk !== null) {
-        extras.push(chunk);
-        void appendDebugLog("context", "provider chunk gathered", {
-          providerId: provider.id,
-          kind: chunk.kind
-        });
-      }
-    } catch (error) {
-      void appendDebugLog("context", "provider error", {
-        providerId: provider.id,
-        message: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  const envelope = filterContextEnvelope({ base, extras });
-  void appendDebugLog("context", "envelope assembled", { extraCount: extras.length });
-  return envelope;
-}
-
-// src/daemon/bootstrap.ts
-import { spawn } from "child_process";
-import * as fs from "fs";
-import * as net from "net";
-import * as path from "path";
-import { fileURLToPath } from "url";
-var CONNECT_TIMEOUT_MS = 500;
-var POLL_INTERVAL_MS = 50;
-var POLL_MAX_ATTEMPTS = 40;
-function tryConnect(socketPath2) {
-  return new Promise((resolve3) => {
-    const timer = setTimeout(() => {
-      client.destroy();
-      resolve3(false);
-    }, CONNECT_TIMEOUT_MS);
-    const client = net.createConnection(socketPath2, () => {
-      clearTimeout(timer);
-      client.destroy();
-      resolve3(true);
-    });
-    client.on("error", () => {
-      clearTimeout(timer);
-      resolve3(false);
-    });
-  });
-}
-async function waitForSocket(socketPath2, maxAttempts = POLL_MAX_ATTEMPTS) {
-  for (let i = 0; i < maxAttempts; i++) {
-    if (await tryConnect(socketPath2)) return true;
-    await new Promise((res) => setTimeout(res, POLL_INTERVAL_MS));
-  }
-  return false;
-}
-function assertSafeSocketPath(socketPath2) {
-  const resolved = path.resolve(socketPath2);
-  const base = path.basename(resolved);
-  const dir = path.dirname(resolved);
-  const tmpRoots = ["/tmp", "/private/tmp"];
-  if (!tmpRoots.includes(dir) || !base.startsWith("qq-") || !base.endsWith(".sock")) {
-    throw new Error(`unsafe socket path rejected: ${socketPath2}`);
-  }
-}
-async function ensureDaemon(socketPath2) {
-  assertSafeSocketPath(socketPath2);
-  void appendDebugLog("daemon", "ensure start", { socketPath: socketPath2 });
-  if (await tryConnect(socketPath2)) {
-    void appendDebugLog("daemon", "already running", { socketPath: socketPath2 });
-    return;
-  }
-  try {
-    fs.unlinkSync(socketPath2);
-  } catch {
-  }
-  const qqBin = process.execPath;
-  const qqScript = fileURLToPath(import.meta.url);
-  if (!fs.existsSync(qqScript)) {
-    void appendDebugLog("daemon", "script missing", { qqScript });
-    throw new Error(`qq daemon script not found at: ${qqScript}. Run 'pnpm build' first.`);
-  }
-  void appendDebugLog("daemon", "spawning daemon", { qqScript, socketPath: socketPath2 });
-  const child = spawn(qqBin, [qqScript, "daemon", "--socket", socketPath2], {
-    detached: true,
-    stdio: "ignore"
-  });
-  child.unref();
-  const started = await waitForSocket(socketPath2);
-  if (!started) {
-    void appendDebugLog("daemon", "startup timeout", { socketPath: socketPath2 });
-    throw new Error(`qq daemon did not start within the expected window (${socketPath2})`);
-  }
-  void appendDebugLog("daemon", "daemon ready", { socketPath: socketPath2 });
-}
-
-// src/providers/detect.ts
-import { execSync } from "child_process";
-import * as fsp2 from "fs/promises";
-import * as os from "os";
-function claudeOnPath() {
-  try {
-    execSync("which claude", { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function claudeAuthFileExists() {
-  const home = os.homedir();
-  const candidates = [`${home}/.claude/.credentials.json`, `${home}/.claude/credentials.json`];
-  for (const p of candidates) {
-    try {
-      await fsp2.stat(p);
-      return true;
-    } catch {
-    }
-  }
-  return false;
-}
-async function ollamaHealthy() {
-  try {
-    const res = await fetch("http://localhost:11434/api/tags", {
-      signal: AbortSignal.timeout(300)
-    });
-    return res.ok;
-  } catch {
-    return false;
-  }
-}
-async function detectProvider() {
-  if (process.env.ANTHROPIC_API_KEY || readEnvValueFromDotEnvLocal("ANTHROPIC_API_KEY")) {
-    return { kind: "anthropic-key" };
-  }
-  if (claudeOnPath() && await claudeAuthFileExists()) {
-    return { kind: "claude-cli" };
-  }
-  if (await ollamaHealthy()) {
-    return { kind: "ollama", baseUrl: "http://localhost:11434" };
-  }
-  if (process.env.OPENAI_API_KEY) {
-    return { kind: "openai-key" };
-  }
-  return {
-    kind: "none",
-    message: "queque: no AI provider configured\nChecked (in order):\n  1. ANTHROPIC_API_KEY env var or .env.local\n  2. Claude CLI (claude on PATH + credentials file)\n  3. Ollama at http://localhost:11434\n  4. OPENAI_API_KEY env var\nSet one of the above and re-trigger ??"
-  };
-}
-
-// src/providers/resolver.ts
-function resolveAdapter(detected) {
-  switch (detected.kind) {
-    case "anthropic-key": {
-      const adapter = getProviderAdapter("claude");
-      if (!adapter) {
-        throw new Error(
-          "QueQue: Claude provider is not registered \u2014 was bootstrapBuiltins() called?"
-        );
-      }
-      return adapter;
-    }
-    case "claude-cli":
-      throw new Error(
-        "QueQue: Claude CLI detected but subprocess adapter is not wired yet (Phase 8). Set ANTHROPIC_API_KEY or use .env.local."
-      );
-    case "ollama":
-      throw new Error(
-        "QueQue: Ollama detected but local adapter is not wired yet (Phase 8). Set ANTHROPIC_API_KEY or use .env.local."
-      );
-    case "openai-key":
-      throw new Error(
-        "QueQue: OPENAI_API_KEY detected but OpenAI adapter is not wired yet (Phase 8). Set ANTHROPIC_API_KEY for Claude."
-      );
-    case "none":
-      throw new Error(detected.message);
-  }
-}
-
-// src/shared/socket-path.ts
-function socketPathForUid(uid) {
-  return `/tmp/qq-${uid}.sock`;
-}
-function socketPath() {
-  return socketPathForUid(process.getuid?.() ?? 0);
-}
-
-// src/ui/CandidateSelect.tsx
-import { Box as Box4, Text as Text4, useInput, useStdin, useStdout as useStdout2 } from "ink";
-import { useEffect as useEffect2, useState as useState2 } from "react";
-
-// src/ui/ControlsLine.tsx
-import { Box, Text } from "ink";
-import { jsx, jsxs } from "react/jsx-runtime";
-function ControlsLine() {
-  return /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
-    /* @__PURE__ */ jsx(Text, { backgroundColor: "ansi256(238)", color: "white", bold: true, children: " \u2191\u2193 " }),
-    /* @__PURE__ */ jsx(Text, { backgroundColor: "ansi256(245)", color: "black", children: " select " }),
-    /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \xB7 " }),
-    /* @__PURE__ */ jsx(Text, { backgroundColor: "ansi256(238)", color: "white", bold: true, children: " enter " }),
-    /* @__PURE__ */ jsx(Text, { backgroundColor: "ansi256(245)", color: "black", children: " accept " }),
-    /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \xB7 " }),
-    /* @__PURE__ */ jsx(Text, { backgroundColor: "ansi256(238)", color: "white", bold: true, children: " esc " }),
-    /* @__PURE__ */ jsx(Text, { backgroundColor: "ansi256(245)", color: "black", children: " cancel " })
-  ] });
-}
-
-// src/ui/LoadingSpinner.tsx
-import { Text as Text2 } from "ink";
-import { useEffect, useState } from "react";
-import { jsx as jsx2 } from "react/jsx-runtime";
-var FRAMES = ["thinking\u2026", "thinking.", "thinking..", "thinking\u2026"];
-function LoadingSpinner() {
-  const [frame, setFrame] = useState(0);
-  useEffect(() => {
-    const id = setInterval(() => {
-      setFrame((f) => (f + 1) % FRAMES.length);
-    }, 200);
-    return () => clearInterval(id);
-  }, []);
-  return /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: FRAMES[frame] });
-}
-
-// src/ui/Modal.tsx
-import { Box as Box2, useStdout } from "ink";
-import { jsx as jsx3 } from "react/jsx-runtime";
-function Modal({ children }) {
-  const { stdout } = useStdout();
-  const width = Math.min(80, stdout.columns || 80);
-  return /* @__PURE__ */ jsx3(Box2, { flexDirection: "column", paddingX: 1, width, children });
-}
-
-// src/ui/modal-layout.ts
-function wrapText(text, maxWidth) {
-  if (maxWidth < 1) {
-    return [text];
-  }
-  const words = text.split(/\s+/).filter((word) => word.length > 0);
-  if (words.length === 0) {
-    return [""];
-  }
-  const lines = [];
-  let line = "";
-  for (const word of words) {
-    let remaining = word;
-    while (remaining.length > 0) {
-      const candidate = line ? `${line} ${remaining}` : remaining;
-      if (candidate.length <= maxWidth) {
-        line = candidate;
-        remaining = "";
-        break;
-      }
-      if (line) {
-        lines.push(line);
-        line = "";
-        continue;
-      }
-      lines.push(remaining.slice(0, maxWidth));
-      remaining = remaining.slice(maxWidth);
-    }
-  }
-  if (line) {
-    lines.push(line);
-  }
-  return lines;
-}
-function normalizeCommand(command) {
-  return command.trim();
-}
-function filterCandidates(candidates, query) {
-  if (!query) return candidates;
-  const lower = query.toLowerCase();
-  return candidates.filter((c) => normalizeCommand(c.command).toLowerCase().includes(lower));
-}
-function estimateCandidateSelectLines(input) {
-  let lines = 0;
-  if (input.initialQuery && input.initialQuery.length > 0) {
-    lines += 1;
-  }
-  lines += 1;
-  lines += 1;
-  if (input.error === true) {
-    lines += 1;
-  } else if (input.candidates === null) {
-    lines += 1;
-  } else {
-    const visible2 = filterCandidates(input.candidates, input.query);
-    if (visible2.length === 0) {
-      lines += 1;
-    } else {
-      for (const candidate of visible2) {
-        const command = normalizeCommand(candidate.command);
-        const commandLines = wrapText(command, input.contentWidth);
-        const explanationLines = candidate.explanation.length > 0 ? wrapText(candidate.explanation, input.contentWidth) : [];
-        lines += commandLines.length + explanationLines.length;
-        lines += 1;
-      }
-    }
-  }
-  const visible = input.candidates !== null && input.error !== true ? filterCandidates(input.candidates, input.query) : [];
-  const selectedCommand = visible[input.selectedIndex]?.command ? normalizeCommand(visible[input.selectedIndex].command) : void 0;
-  const showDestructiveWarning = selectedCommand !== void 0 && isDestructiveCommand(selectedCommand);
-  if (showDestructiveWarning) {
-    lines += 1;
-    lines += 1;
-  }
-  lines += 1;
-  lines += 1;
-  if (input.includeDevFooter) {
-    lines += 1;
-  }
-  return lines;
-}
-
-// src/ui/SearchInput.tsx
-import { Box as Box3, Text as Text3 } from "ink";
-import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
-function SearchInput({ query }) {
-  return /* @__PURE__ */ jsxs2(Box3, { children: [
-    /* @__PURE__ */ jsx4(Text3, { color: "cyan", bold: true, children: "FILTER: " }),
-    query ? /* @__PURE__ */ jsx4(Text3, { children: query }) : /* @__PURE__ */ jsx4(Text3, { dimColor: true, children: "type to filter\u2026" })
-  ] });
-}
-
-// src/ui/CandidateSelect.tsx
-import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
-var ROW_GUTTER = "   ";
-var ACTIVE_HEAD = "\u250C> ";
-var ACTIVE_TAIL = "\u2502  ";
-var DESTRUCTIVE_WARNING_MARK = "\u26A0";
-var DESTRUCTIVE_WARNING_TEXT = `${DESTRUCTIVE_WARNING_MARK} review carefully \u2014 this command may be destructive`;
-var MODAL_MAX_WIDTH = 80;
-var MODAL_PADDING_X = 2;
-function linePrefix(active, lineIndex) {
-  if (!active) {
-    return ROW_GUTTER;
-  }
-  return lineIndex === 0 ? ACTIVE_HEAD : ACTIVE_TAIL;
-}
-function normalizeCommand2(command) {
-  return command.trim();
-}
-function CandidateSelect({
-  candidates,
-  initialQuery,
-  onSelect,
-  onCancel,
-  error,
-  onLayoutLinesChange
-}) {
-  const { isRawModeSupported } = useStdin();
-  const { stdout } = useStdout2();
-  const modalWidth = Math.min(MODAL_MAX_WIDTH, stdout.columns || MODAL_MAX_WIDTH);
-  const contentWidth = modalWidth - MODAL_PADDING_X - ROW_GUTTER.length;
-  const [selectedIndex, setSelectedIndex] = useState2(0);
-  const [query, setQuery] = useState2(initialQuery ?? "");
-  useEffect2(() => {
-    if (!isRawModeSupported) {
-      onCancel();
-    }
-  }, [isRawModeSupported, onCancel]);
-  useEffect2(() => {
-    setSelectedIndex(0);
-    if (candidates && candidates.length > 0 && filterCandidates(candidates, query).length === 0) {
-      setQuery("");
-    }
-  }, [candidates]);
-  useEffect2(() => {
-    setSelectedIndex(0);
-  }, [query]);
-  const includeDevFooter = process.env.QQ_DEV_ROOT != null;
-  useEffect2(() => {
-    if (!onLayoutLinesChange) {
+    if (process.env.NODE_COMPILE_CACHE !== void 0 || process.env.NODE_DISABLE_COMPILE_CACHE !== void 0) {
       return;
     }
-    if (candidates === null && error !== true) {
+    const enableCompileCache2 = nodeModule.enableCompileCache;
+    if (typeof enableCompileCache2 !== "function" || typeof process.getuid !== "function") {
       return;
     }
-    onLayoutLinesChange(
-      estimateCandidateSelectLines({
-        candidates,
-        initialQuery,
-        query,
-        selectedIndex,
-        error,
-        contentWidth,
-        includeDevFooter
-      })
-    );
-  }, [
-    candidates,
-    initialQuery,
-    query,
-    selectedIndex,
-    error,
-    contentWidth,
-    includeDevFooter,
-    onLayoutLinesChange
-  ]);
-  useInput(
-    (input, key) => {
-      if (key.escape) {
-        onCancel();
-        return;
-      }
-      if (key.backspace) {
-        setQuery((q) => q.slice(0, -1));
-        return;
-      }
-      if (key.return && candidates) {
-        const visible = filterCandidates(candidates, query);
-        if (visible.length === 0) return;
-        const selected = visible[selectedIndex] ?? visible[0];
-        const command = normalizeCommand2(selected.command);
-        const explanation = selected.explanation || `see man ${command.split(" ")[0]}`;
-        onSelect(command, explanation);
-        return;
-      }
-      if (input && !key.ctrl && !key.meta) {
-        setQuery((q) => q + input);
-        return;
-      }
-      if (key.upArrow && candidates) {
-        const visible = filterCandidates(candidates, query);
-        setSelectedIndex((i) => i === 0 ? visible.length - 1 : i - 1);
-        return;
-      }
-      if (key.downArrow && candidates) {
-        const visible = filterCandidates(candidates, query);
-        setSelectedIndex((i) => (i + 1) % visible.length);
-        return;
-      }
-    },
-    { isActive: isRawModeSupported }
-  );
-  let content;
-  let showDestructiveWarning = false;
-  if (error === true) {
-    content = /* @__PURE__ */ jsx5(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text4, { dimColor: true, children: "provider error \u2014 press esc to return" }) });
-  } else if (candidates === null) {
-    content = /* @__PURE__ */ jsx5(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx5(LoadingSpinner, {}) });
-  } else {
-    const visible = filterCandidates(candidates, query);
-    const selectedCommand = visible[selectedIndex]?.command ? normalizeCommand2(visible[selectedIndex].command) : void 0;
-    showDestructiveWarning = selectedCommand !== void 0 && isDestructiveCommand(selectedCommand);
-    if (visible.length === 0) {
-      content = /* @__PURE__ */ jsx5(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text4, { dimColor: true, children: "no matches \u2014 try a different query" }) });
-    } else {
-      content = /* @__PURE__ */ jsx5(Box4, { flexDirection: "column", marginTop: 1, children: visible.map((candidate, index) => {
-        const active = index === selectedIndex;
-        const command = normalizeCommand2(candidate.command);
-        const destructive = isDestructiveCommand(command);
-        const commandLines = wrapText(command, contentWidth);
-        const explanationLines = candidate.explanation.length > 0 ? wrapText(candidate.explanation, contentWidth) : [];
-        const blockLines = [...commandLines, ...explanationLines];
-        return /* @__PURE__ */ jsx5(
-          Box4,
-          {
-            flexDirection: "column",
-            marginBottom: 1,
-            children: blockLines.map((line, lineIndex) => {
-              const isCommandLine = lineIndex < commandLines.length;
-              const isLastCommandLine = isCommandLine && lineIndex === commandLines.length - 1;
-              const prefix = linePrefix(active, lineIndex);
-              return /* @__PURE__ */ jsxs3(Box4, { children: [
-                /* @__PURE__ */ jsx5(Text4, { color: active ? "ansi256(166)" : void 0, children: prefix }),
-                /* @__PURE__ */ jsx5(
-                  Text4,
-                  {
-                    bold: active && isCommandLine,
-                    color: active && isCommandLine ? "white" : void 0,
-                    dimColor: !active || !isCommandLine,
-                    children: line
-                  }
-                ),
-                isLastCommandLine && destructive && /* @__PURE__ */ jsx5(Text4, { color: "yellow", children: ` ${DESTRUCTIVE_WARNING_MARK}` })
-              ] }, `${prefix}${line}`);
-            })
-          },
-          `${command}::${candidate.explanation}`
-        );
-      }) });
-    }
-  }
-  return /* @__PURE__ */ jsxs3(Modal, { children: [
-    initialQuery && initialQuery.length > 0 && /* @__PURE__ */ jsx5(Box4, { flexGrow: 0, height: 1, children: /* @__PURE__ */ jsx5(Text4, { dimColor: true, wrap: "truncate", children: `queque \u203A ${initialQuery}` }) }),
-    /* @__PURE__ */ jsx5(SearchInput, { query }),
-    content,
-    showDestructiveWarning && /* @__PURE__ */ jsx5(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text4, { color: "yellow", children: DESTRUCTIVE_WARNING_TEXT }) }),
-    /* @__PURE__ */ jsx5(ControlsLine, {}),
-    process.env.QQ_DEV_ROOT != null && /* @__PURE__ */ jsx5(Box4, { justifyContent: "flex-end", children: /* @__PURE__ */ jsx5(Text4, { color: "yellow", children: `dev v${"0.4.2"} ${"bad1456"}` }) })
-  ] });
-}
-
-// src/client/result-writer.ts
-import * as fsp3 from "fs/promises";
-async function writeShellResult(resultFile, result) {
-  const parsed = shellResultSchema.parse(result);
-  const line = `${JSON.stringify(parsed)}
-`;
-  let isFifo = false;
-  try {
-    const st = await fsp3.stat(resultFile);
-    isFifo = st.isFIFO();
-  } catch {
-  }
-  if (isFifo) {
-    await fsp3.writeFile(resultFile, line, { encoding: "utf-8" });
-  } else {
-    const tmpFile = `${resultFile}.tmp`;
-    await fsp3.writeFile(tmpFile, line, { encoding: "utf-8" });
-    await fsp3.rename(tmpFile, resultFile);
-  }
-}
-
-// src/client/zellij-pane-resize.ts
-import { spawn as spawn2 } from "child_process";
-var DEFAULT_MAX_PANE_HEIGHT = 24;
-var MIN_PANE_HEIGHT = 6;
-var ZELLIJ_FLOATING_FRAME_LINES = 2;
-var lastSyncedHeight;
-function readMaxZellijPaneHeight() {
-  const parsed = Number.parseInt(process.env.QQ_PANE_HEIGHT ?? "", 10);
-  if (Number.isFinite(parsed) && parsed >= MIN_PANE_HEIGHT) {
-    return parsed;
-  }
-  return DEFAULT_MAX_PANE_HEIGHT;
-}
-function resolveZellijPaneHeight(contentLines, maxHeight = readMaxZellijPaneHeight()) {
-  const withFrame = contentLines + ZELLIJ_FLOATING_FRAME_LINES;
-  return Math.min(Math.max(withFrame, MIN_PANE_HEIGHT), maxHeight);
-}
-function formatZellijPaneId(rawPaneId) {
-  if (rawPaneId.startsWith("terminal_") || rawPaneId.startsWith("plugin_")) {
-    return rawPaneId;
-  }
-  return `terminal_${rawPaneId}`;
-}
-function syncZellijFloatingPaneHeight(contentLines) {
-  if (process.env.ZELLIJ === void 0) {
-    return;
-  }
-  const rawPaneId = process.env.ZELLIJ_PANE_ID;
-  if (rawPaneId === void 0 || rawPaneId.length === 0) {
-    return;
-  }
-  const height = resolveZellijPaneHeight(contentLines);
-  if (height === lastSyncedHeight) {
-    return;
-  }
-  lastSyncedHeight = height;
-  const paneId = formatZellijPaneId(rawPaneId);
-  const child = spawn2(
-    "zellij",
-    ["action", "change-floating-pane-coordinates", "--pane-id", paneId, "--height", String(height)],
-    { stdio: "ignore" }
-  );
-  child.unref();
-}
-
-// src/client/run-foreground.ts
-function buildShellBuffers(command, explanation) {
-  const comment = `  # ${explanation}`;
-  const stripped = command.replace(/<([^>]+)>/g, "$1");
-  const firstAngle = command.indexOf("<");
-  if (firstAngle >= 0) {
-    return {
-      lbuffer: stripped.slice(0, firstAngle),
-      rbuffer: stripped.slice(firstAngle) + comment
-    };
-  }
-  return { lbuffer: command, rbuffer: comment };
-}
-async function runForegroundClient(args) {
-  const { requestFile, resultFile, resultMode } = args;
-  const uid = typeof process.getuid === "function" ? process.getuid() : 0;
-  const socketPath2 = socketPathForUid(uid);
-  const inZellij = process.env.ZELLIJ !== void 0;
-  void appendDebugLog("client", "foreground start", {
-    requestFile,
-    resultFile,
-    resultMode,
-    socketPath: socketPath2,
-    inZellij
-  });
-  const ttyHandle = await fsp4.open("/dev/tty", "r+").catch(() => null);
-  try {
-    const raw = await fsp4.readFile(requestFile, "utf-8");
-    const request = shellRequestSchema.parse(JSON.parse(raw.trim()));
-    void appendDebugLog("client", "request parsed", {
-      lbufferLength: request.lbuffer.length,
-      rbufferLength: request.rbuffer.length,
-      cwd: request.cwd,
-      shellPid: request.shellPid
-    });
-    const detectedProvider = await detectProvider();
-    void appendDebugLog("client", "provider detected", { kind: detectedProvider.kind });
-    if (detectedProvider.kind === "none") {
-      if (ttyHandle && !inZellij) {
-        try {
-          await ttyHandle.write(`\r
-${detectedProvider.message}\r
-`);
-        } catch {
-        }
-      }
-      await writeShellResult(resultFile, { kind: "error", message: detectedProvider.message });
+    const xdgCacheHome = process.env.XDG_CACHE_HOME;
+    const cacheRoot = xdgCacheHome !== void 0 && isAbsolute(xdgCacheHome) ? xdgCacheHome : join(homedir(), ".cache");
+    const appDir = join(cacheRoot, "queque");
+    const cacheDir = join(appDir, "node-compile-cache");
+    mkdirSync(cacheDir, { recursive: true, mode: 448 });
+    const uid = process.getuid();
+    if (!isPrivateDirectory(appDir, uid) || !isPrivateDirectory(cacheDir, uid)) {
       return;
     }
-    await ensureDaemon(socketPath2);
-    void appendDebugLog("client", "daemon ensured", { socketPath: socketPath2 });
-    if (resultMode === "replace-buffer-fixture") {
-      const fixtureLbuffer = request.lbuffer || "echo hello";
-      await writeShellResult(resultFile, {
-        kind: "replace-buffer",
-        lbuffer: fixtureLbuffer,
-        rbuffer: request.rbuffer
-      });
-      void appendDebugLog("client", "wrote replace-buffer result", {
-        resultFile,
-        lbufferLength: fixtureLbuffer.length,
-        rbufferLength: request.rbuffer.length
-      });
-    } else if (resultMode === "llm") {
-      let ttyReadStream;
-      let ttyWriteStream;
-      try {
-        const decision = classifyIntent({ ...request, intent: "unknown", confidence: 0 });
-        void appendDebugLog("client", "intent classified", {
-          intent: decision.intent,
-          signals: decision.signals
-        });
-        const normalized = {
-          ...request,
-          intent: decision.intent,
-          confidence: decision.confidence
-        };
-        const envelope = await gatherContext(normalized);
-        void appendDebugLog("client", "context gathered", {
-          extraCount: envelope.extras.length
-        });
-        const adapter = resolveAdapter(detectedProvider);
-        void appendDebugLog("client", "provider adapter resolved", { kind: detectedProvider.kind });
-        if (ttyHandle) {
-          try {
-            ttyReadStream = new tty.ReadStream(ttyHandle.fd);
-            ttyWriteStream = new tty.WriteStream(ttyHandle.fd);
-          } catch {
-          }
-        }
-        if (!ttyReadStream || !ttyWriteStream) {
-          const msg = "\r\nqueque: could not open terminal for interactive input\r\n";
-          if (ttyHandle) {
-            try {
-              await ttyHandle.write(msg);
-            } catch {
-            }
-          }
-          await writeShellResult(resultFile, { kind: "error", message: msg.trim() });
-          return;
-        }
-        try {
-          ttyReadStream.setRawMode(true);
-          ttyReadStream.setRawMode(false);
-        } catch {
-          const msg = "\r\nqueque: terminal does not support interactive mode\r\nRun ?? from an interactive ZSH session.\r\n";
-          ttyWriteStream.write(msg);
-          await writeShellResult(resultFile, {
-            kind: "error",
-            message: "queque: terminal does not support interactive mode \u2014 run ?? from an interactive shell"
-          });
-          return;
-        }
-        const MODAL_VIEWPORT_LINES = 16;
-        if (ttyWriteStream && !inZellij) {
-          ttyWriteStream.write("\n".repeat(MODAL_VIEWPORT_LINES));
-          ttyWriteStream.write(`\x1B[${MODAL_VIEWPORT_LINES}A`);
-          ttyWriteStream.write("\x1B7");
-        }
-        await new Promise((resolve3) => {
-          let unmount;
-          let resolved = false;
-          const buildCandidateElement = (candidates, errorState) => React.createElement(CandidateSelect, {
-            candidates,
-            initialQuery: request.lbuffer,
-            error: errorState,
-            onSelect: async (command, explanation) => {
-              if (resolved) return;
-              resolved = true;
-              const { lbuffer, rbuffer } = buildShellBuffers(command, explanation);
-              await writeShellResult(resultFile, {
-                kind: "replace-buffer",
-                lbuffer,
-                rbuffer,
-                query: request.lbuffer
-              });
-              unmount?.();
-            },
-            onCancel: async () => {
-              if (resolved) return;
-              resolved = true;
-              await writeShellResult(resultFile, { kind: "cancel" });
-              unmount?.();
-            },
-            onLayoutLinesChange: inZellij ? syncZellijFloatingPaneHeight : void 0
-          });
-          const renderOptions = ttyReadStream && ttyWriteStream ? { stdin: ttyReadStream, stdout: ttyWriteStream, interactive: true } : { interactive: true };
-          const app = render(buildCandidateElement(null), renderOptions);
-          const clearScrollReserve = () => {
-            if (ttyWriteStream && !inZellij) {
-              try {
-                ttyWriteStream.write("\x1B8\x1B[J");
-              } catch {
-              }
-            }
-          };
-          const cleanupOnSignal = () => {
-            app.unmount();
-            clearScrollReserve();
-            process.exit(0);
-          };
-          process.once("SIGHUP", cleanupOnSignal);
-          process.once("SIGTERM", cleanupOnSignal);
-          unmount = (skipClear = false) => {
-            process.off("SIGHUP", cleanupOnSignal);
-            process.off("SIGTERM", cleanupOnSignal);
-            app.unmount();
-            if (!skipClear) clearScrollReserve();
-            resolve3();
-          };
-          adapter.fetchCandidates(envelope).then((candidates) => {
-            void appendDebugLog("client", "candidates received", { count: candidates.length });
-            app.rerender(buildCandidateElement(candidates));
-          }).catch(async (err) => {
-            const message = err instanceof Error ? err.message : String(err);
-            void appendDebugLog("client", "llm request failed", { message });
-            if (resolved) return;
-            resolved = true;
-            const errorMsg = `QueQue: ${message}`;
-            await writeShellResult(resultFile, { kind: "error", message: errorMsg });
-            unmount?.(true);
-          });
-        });
-        void appendDebugLog("client", "wrote llm result", { resultFile });
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        void appendDebugLog("client", "llm request failed", { message });
-        const errorMsg = `QueQue: ${message}`;
-        await writeShellResult(resultFile, { kind: "error", message: errorMsg });
-      }
-    } else {
-      await writeShellResult(resultFile, { kind: "cancel" });
-      void appendDebugLog("client", "wrote cancel result", { resultFile });
-    }
-  } finally {
-    await ttyHandle?.close();
-  }
-}
-
-// src/cli/commands/client.ts
-function parseResultMode(mode) {
-  if (mode === void 0 || mode === "llm") return "llm";
-  if (mode === "cancel") return "cancel";
-  if (mode === "replace-buffer-fixture") return "replace-buffer-fixture";
-  void appendDebugLog("client", `unknown --result-mode "${mode}", defaulting to cancel`);
-  return "cancel";
-}
-async function clientCommand(options) {
-  const resultMode = parseResultMode(options.resultMode);
-  void appendDebugLog("client", "command start", {
-    requestFile: options.requestFile,
-    resultFile: options.resultFile,
-    resultMode
-  });
-  await runForegroundClient({
-    requestFile: options.requestFile,
-    resultFile: options.resultFile,
-    resultMode
-  });
-}
-
-// src/daemon/server.ts
-import * as net2 from "net";
-
-// src/contracts/ipc.ts
-import { z as z5 } from "zod";
-var ipcRequestSchema = z5.discriminatedUnion("kind", [
-  z5.object({
-    kind: z5.literal("ping")
-  }),
-  z5.object({
-    kind: z5.literal("ensure-session"),
-    shellPid: z5.number().int().positive(),
-    ttyPath: z5.string()
-  }),
-  z5.object({
-    kind: z5.literal("run-query"),
-    request: shellRequestSchema
-  })
-]);
-var ipcResponseSchema = z5.discriminatedUnion("kind", [
-  z5.object({
-    kind: z5.literal("pong")
-  }),
-  z5.object({
-    kind: z5.literal("session-ready"),
-    socketPath: z5.string()
-  }),
-  z5.object({
-    kind: z5.literal("query-accepted"),
-    requestId: z5.string()
-  })
-]);
-
-// src/daemon/server.ts
-function startDaemonServer(socketPath2) {
-  return new Promise((resolve3, reject) => {
-    const MAX_BUF_BYTES = 64 * 1024;
-    const server = net2.createServer((socket) => {
-      let buf = "";
-      void appendDebugLog("daemon", "socket connected", { socketPath: socketPath2 });
-      socket.on("data", (chunk) => {
-        if (buf.length + chunk.length > MAX_BUF_BYTES) {
-          socket.destroy(new Error("IPC message too large"));
-          return;
-        }
-        buf += chunk.toString();
-        let nl = buf.indexOf("\n");
-        while (nl !== -1) {
-          const line = buf.slice(0, nl).trim();
-          buf = buf.slice(nl + 1);
-          nl = buf.indexOf("\n");
-          if (!line) continue;
-          let parsed;
-          try {
-            parsed = JSON.parse(line);
-          } catch {
-            continue;
-          }
-          const result = ipcRequestSchema.safeParse(parsed);
-          if (!result.success) {
-            void appendDebugLog("daemon", "ignored unknown request", { line });
-            continue;
-          }
-          const req = result.data;
-          void appendDebugLog("daemon", "request received", req);
-          switch (req.kind) {
-            case "ping": {
-              socket.write(`${JSON.stringify({ kind: "pong" })}
-`);
-              void appendDebugLog("daemon", "replied pong");
-              break;
-            }
-            case "ensure-session": {
-              socket.write(`${JSON.stringify({ kind: "session-ready", socketPath: socketPath2 })}
-`);
-              void appendDebugLog("daemon", "replied session-ready", { socketPath: socketPath2 });
-              break;
-            }
-            case "run-query": {
-              const requestId = Math.random().toString(36).slice(2);
-              socket.write(`${JSON.stringify({ kind: "query-accepted", requestId })}
-`);
-              void appendDebugLog("daemon", "replied query-accepted", { requestId });
-              break;
-            }
-          }
-        }
-      });
-      socket.on("error", () => {
-      });
-    });
-    server.on("error", reject);
-    server.listen(socketPath2, () => {
-      void appendDebugLog("daemon", "listening", { socketPath: socketPath2 });
-      resolve3(server);
-    });
-  });
-}
-
-// src/cli/commands/daemon.ts
-async function daemonCommand(options) {
-  const sock = options.socket ?? socketPath();
-  void appendDebugLog("daemon", "command start", { socket: sock, ensure: options.ensure });
-  if (options.ensure) {
-    await ensureDaemon(sock);
-    void appendDebugLog("daemon", "ensure command complete", { socket: sock });
-    return;
-  }
-  const server = await startDaemonServer(sock);
-  void appendDebugLog("daemon", "server started", { socket: sock });
-  const shutdown = () => {
-    void appendDebugLog("daemon", "shutdown", { socket: sock });
-    server.close(() => {
-      process.exit(0);
-    });
-  };
-  process.once("SIGTERM", shutdown);
-  process.once("SIGINT", shutdown);
-  await new Promise(() => {
-  });
-}
-
-// src/cli/commands/init.ts
-import { appendFileSync, existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname3, join as join3, resolve as resolve2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-var __dirname = dirname3(fileURLToPath2(import.meta.url));
-var HOMEBREW_PREFIXES = ["/opt/homebrew", "/usr/local", "/home/linuxbrew/.linuxbrew"];
-function _resolveScriptPath(shell) {
-  for (const prefix of HOMEBREW_PREFIXES) {
-    const p = resolve2(prefix, "share", "queque", `queque.${shell}`);
-    if (existsSync3(p)) return p;
-  }
-  return resolve2(__dirname, "../../shell", shell, `queque.${shell}`);
-}
-function hasShellIntegration(existing, shell) {
-  if (/# queque shell integration/.test(existing)) {
-    return true;
+    enableCompileCache2(cacheDir);
+  } catch {
   }
-  const scriptPattern = new RegExp(`source\\s+["'][^"']*queque\\.${shell.replace(".", "\\.")}["']`);
-  return scriptPattern.test(existing);
 }
-function initCommand(shell) {
-  bootstrapBuiltins();
-  const supportedShells = listShellAdapters().map((adapter) => adapter.shell);
-  if (!supportedShells.includes(shell)) {
-    console.error(`Unsupported shell: '${shell}'. Supported: ${supportedShells.join(", ")}`);
-    process.exit(1);
-  }
-  const zshrc = join3(homedir3(), ".zshrc");
-  const scriptPath = _resolveScriptPath(shell);
-  const snippet = `source "${scriptPath}"`;
-  const existing = existsSync3(zshrc) ? readFileSync3(zshrc, "utf8") : "";
-  if (hasShellIntegration(existing, shell)) {
-    console.error("queque: shell integration already present in ~/.zshrc");
-    process.exit(0);
-  }
-  appendFileSync(zshrc, `
-# queque shell integration
-${snippet}
+enablePerUserCompileCache();
+var appUrl = new URL("./app.js", import.meta.url).href;
+try {
+  const app = await import(appUrl);
+  await app.main();
+} catch (error) {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}
 `);
-  console.log("queque: added shell integration to ~/.zshrc \u2014 run: source ~/.zshrc");
-}
-
-// src/cli/main.ts
-function requiredOption(name, value) {
-  if (!value) {
-    throw new Error(`Missing required option: ${name}`);
-  }
-  return value;
-}
-var QQ_RESULT_FILE_PATTERN = /^\/tmp\/qq-sess\.[A-Za-z0-9]+\//;
-process.on("uncaughtException", (err) => {
-  console.error("QueQue: uncaught exception:", err.message);
-  const resultFile = process.env.QQ_RESULT_FILE;
-  if (resultFile && QQ_RESULT_FILE_PATTERN.test(resultFile)) {
-    try {
-      fs2.writeFileSync(resultFile, '{"kind":"cancel"}\n');
-    } catch {
-    }
-  }
-  process.exit(1);
-});
-process.on("unhandledRejection", (reason) => {
-  const message = reason instanceof Error ? reason.message : String(reason);
-  console.error("QueQue: unhandled rejection:", message);
-  const resultFile = process.env.QQ_RESULT_FILE;
-  if (resultFile && QQ_RESULT_FILE_PATTERN.test(resultFile)) {
-    try {
-      fs2.writeFileSync(resultFile, '{"kind":"cancel"}\n');
-    } catch {
-    }
-  }
-  process.exit(1);
-});
-async function main(argv = process.argv.slice(2)) {
-  bootstrapBuiltins();
-  const cli = cac("qq");
-  cli.command("client").option("--request-file <path>", "Path to the serialized shell request").option("--result-file <path>", "Path to write the serialized shell result").option("--result-mode <mode>", "Result mode: llm | cancel | replace-buffer-fixture").action(async (options) => {
-    const requestFile = requiredOption("--request-file", options.requestFile);
-    const resultFile = requiredOption("--result-file", options.resultFile);
-    await clientCommand({ requestFile, resultFile, resultMode: options.resultMode });
-  });
-  cli.command(
-    "init <shell>",
-    "Print a source line for shell integration (append to ~/.zshrc with `qq init zsh >> ~/.zshrc`)"
-  ).action((shell) => {
-    initCommand(shell);
-  });
-  cli.command("daemon").option("--socket <path>", "Unix socket path for the daemon").option("--ensure", "Ensure the daemon is running before returning").action(async (options) => {
-    await daemonCommand(options);
-  });
-  cli.help();
-  cli.parse(["node", "qq", ...argv], { run: false });
-  await cli.runMatchedCommand();
-}
-var isDirectRun = process.argv[1] ? import.meta.url === new URL(`file://${fs2.realpathSync(process.argv[1])}`).href : false;
-if (isDirectRun) {
-  void main().catch((error) => {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(message);
-    process.exitCode = 1;
-  });
+  process.exitCode = 1;
 }
-export {
-  main
-};
 //# sourceMappingURL=main.js.map