@duckmind/dm-windows-x64 0.62.3 → 0.63.0

package/extensions/dm-ponytail/extensions/ponytail.mjs

@@ -0,0 +1,186 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const {
+  DEFAULT_MODE,
+  RUNTIME_MODES,
+  getDefaultMode,
+  getQuietStartup,
+  getHideStatus,
+  normalizeMode,
+  normalizePersistedMode,
+  isDeactivationCommand,
+  writeDefaultMode
+} = require("../hooks/ponytail-config.js");
+const { getPonytailInstructions, filterSkillBodyForMode } = require("../hooks/ponytail-instructions.js");
+
+export { filterSkillBodyForMode };
+export const readDefaultMode = getDefaultMode;
+export const readQuietStartup = getQuietStartup;
+const RUNTIME_MODE_LIST = RUNTIME_MODES.join("|");
+const PONYTAIL_COMMAND_DESCRIPTION = `Set mode: ${RUNTIME_MODE_LIST}. Commands: status, default <mode>`;
+export function resolveSessionMode(entries, fallbackMode = DEFAULT_MODE) {
+  const fallback = normalizePersistedMode(fallbackMode) || DEFAULT_MODE;
+  if (!Array.isArray(entries))
+    return fallback;
+  for (let i = entries.length - 1;i >= 0; i -= 1) {
+    const entry = entries[i];
+    if (entry?.type !== "custom" || entry?.customType !== "ponytail-mode")
+      continue;
+    const mode = normalizePersistedMode(entry?.data?.mode);
+    if (mode)
+      return mode;
+  }
+  return fallback;
+}
+export function parsePonytailCommand(text, defaultMode = DEFAULT_MODE) {
+  const fallback = normalizePersistedMode(defaultMode) || DEFAULT_MODE;
+  const normalizedText = String(text || "").trim().toLowerCase();
+  if (!normalizedText) {
+    return { type: "set-mode", mode: fallback === "off" ? "full" : fallback };
+  }
+  const [primary, secondary] = normalizedText.split(/\s+/);
+  if (primary === "status")
+    return { type: "status" };
+  if (primary === "default") {
+    const mode = normalizeMode(secondary);
+    return mode ? { type: "set-default", mode } : { type: "invalid", reason: "invalid-default-mode" };
+  }
+  const mode = normalizeMode(primary);
+  return mode ? { type: "set-mode", mode } : { type: "invalid", reason: "invalid-mode", mode: primary };
+}
+
+export { writeDefaultMode };
+export default function ponytailExtension(pi) {
+  let currentMode = DEFAULT_MODE;
+  let configuredDefaultMode = getDefaultMode();
+  let hideStatus = getHideStatus();
+  let isActive = false;
+  let lastCtx = null;
+  function syncStatus(ctx) {
+    if (ctx)
+      lastCtx = ctx;
+    const c = ctx || lastCtx;
+    if (hideStatus)
+      return;
+    if (!c?.ui?.setStatus)
+      return;
+    let theme;
+    try {
+      theme = c.ui.theme;
+      if (!theme?.fg)
+        return;
+    } catch {
+      return;
+    }
+    if (currentMode === "off") {
+      c.ui.setStatus("ponytail", "");
+      return;
+    }
+    const levelIcons = { lite: "\uD83C\uDF3F", full: "⚡", ultra: "\uD83D\uDD25" };
+    const icon = levelIcons[currentMode] || "";
+    const label = currentMode.toUpperCase();
+    const indicator = isActive ? theme.fg("accent", "●") : theme.fg("dim", "○");
+    c.ui.setStatus("ponytail", indicator + " " + theme.fg("muted", "token saver: ") + theme.fg("text", icon + " " + label));
+  }
+  const setMode = (mode, ctx) => {
+    const normalized = normalizePersistedMode(mode);
+    if (!normalized)
+      return;
+    currentMode = normalized;
+    pi.appendEntry("ponytail-mode", { mode: normalized });
+    syncStatus(ctx);
+    ctx?.ui?.notify?.(`Ponytail mode set to ${normalized}.`, "info");
+  };
+  const sendAlias = (skillName, args, ctx) => {
+    const normalized = String(args || "").trim();
+    const message = normalized ? `${skillName} ${normalized}` : skillName;
+    if (ctx?.isIdle?.() === false) {
+      pi.sendUserMessage(message, { deliverAs: "followUp" });
+      ctx?.ui?.notify?.(`${skillName} queued as follow-up.`, "info");
+      return;
+    }
+    pi.sendUserMessage(message);
+  };
+  pi.registerCommand("ponytail", {
+    description: PONYTAIL_COMMAND_DESCRIPTION,
+    handler: async (args, ctx) => {
+      const parsed = parsePonytailCommand(args, configuredDefaultMode);
+      if (parsed.type === "status") {
+        ctx?.ui?.notify?.(`Ponytail: current ${currentMode} • default ${configuredDefaultMode}`, "info");
+        return;
+      }
+      if (parsed.type === "set-default") {
+        try {
+          const written = writeDefaultMode(parsed.mode);
+          if (written) {
+            configuredDefaultMode = getDefaultMode();
+            const message = configuredDefaultMode === written ? `Default Ponytail mode set to ${written}.` : `Saved default ${written}, but env override keeps default at ${configuredDefaultMode}.`;
+            ctx?.ui?.notify?.(message, "info");
+          }
+        } catch (e) {
+          ctx?.ui?.notify?.(`Failed to save default mode: ${e.message}`, "error");
+        }
+        return;
+      }
+      if (parsed.type === "set-mode") {
+        setMode(parsed.mode, ctx);
+        return;
+      }
+      ctx?.ui?.notify?.("Unknown or unsupported /ponytail mode.", "warning");
+    }
+  });
+  pi.registerCommand("ponytail-review", {
+    description: "Run /skill:ponytail-review",
+    handler: (_args, ctx) => sendAlias("/skill:ponytail-review", "", ctx)
+  });
+  pi.registerCommand("ponytail-audit", {
+    description: "Run /skill:ponytail-audit",
+    handler: (_args, ctx) => sendAlias("/skill:ponytail-audit", "", ctx)
+  });
+  pi.registerCommand("ponytail-gain", {
+    description: "Run /skill:ponytail-gain",
+    handler: (_args, ctx) => sendAlias("/skill:ponytail-gain", "", ctx)
+  });
+  pi.registerCommand("ponytail-debt", {
+    description: "Run /skill:ponytail-debt",
+    handler: (_args, ctx) => sendAlias("/skill:ponytail-debt", "", ctx)
+  });
+  pi.registerCommand("ponytail-help", {
+    description: "Run /skill:ponytail-help",
+    handler: (_args, ctx) => sendAlias("/skill:ponytail-help", "", ctx)
+  });
+  pi.on("input", async (event) => {
+    if (event?.source === "extension")
+      return;
+    const text = String(event?.text || "");
+    if (currentMode !== "off" && isDeactivationCommand(text)) {
+      setMode("off");
+    }
+  });
+  pi.on("session_start", async (_event, ctx) => {
+    const entries = ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
+    configuredDefaultMode = getDefaultMode();
+    hideStatus = getHideStatus();
+    currentMode = resolveSessionMode(entries, configuredDefaultMode);
+    syncStatus(ctx);
+    if (!getQuietStartup()) {
+      ctx?.ui?.notify?.(`DM Ponytail loaded: ${currentMode}`, "info");
+    }
+  });
+  pi.on("agent_start", async (_event, ctx) => {
+    isActive = true;
+    syncStatus(ctx);
+  });
+  pi.on("agent_end", async (_event, ctx) => {
+    isActive = false;
+    syncStatus(ctx);
+  });
+  pi.on("before_agent_start", async (event) => {
+    if (!currentMode || currentMode === "off")
+      return;
+    const base = event?.systemPrompt ? `${event.systemPrompt}
+
+` : "";
+    return { systemPrompt: `${base}${getPonytailInstructions(currentMode)}` };
+  });
+}

package/extensions/dm-ponytail/hooks/claude-codex-hooks.json

@@ -0,0 +1,41 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/ponytail-activate.js\"",
+            "timeout": 5,
+            "statusMessage": "Loading ponytail mode..."
+          }
+        ]
+      }
+    ],
+    "SubagentStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/ponytail-subagent.js\"",
+            "timeout": 5,
+            "statusMessage": "Loading ponytail mode..."
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/ponytail-mode-tracker.js\"",
+            "timeout": 5,
+            "statusMessage": "Tracking ponytail mode..."
+          }
+        ]
+      }
+    ]
+  }
+}

package/extensions/dm-ponytail/hooks/copilot-hooks.json

@@ -0,0 +1,21 @@
+{
+  "version": 1,
+  "hooks": {
+    "sessionStart": [
+      {
+        "type": "command",
+        "bash": "node \"${PLUGIN_ROOT}/hooks/ponytail-activate.js\"",
+        "powershell": "node \"${PLUGIN_ROOT}\\hooks\\ponytail-activate.js\"",
+        "timeoutSec": 5
+      }
+    ],
+    "userPromptSubmitted": [
+      {
+        "type": "command",
+        "bash": "node \"${PLUGIN_ROOT}/hooks/ponytail-mode-tracker.js\"",
+        "powershell": "node \"${PLUGIN_ROOT}\\hooks\\ponytail-mode-tracker.js\"",
+        "timeoutSec": 5
+      }
+    ]
+  }
+}

package/extensions/dm-ponytail/hooks/ponytail-activate.js

@@ -0,0 +1,59 @@
+var __dirname = "/Users/que/Projects/dm/dm-mono/packages/coding-agent/dist/extensions/dm-ponytail/hooks";
+const fs = require("fs");
+const path = require("path");
+const { getDefaultMode, getClaudeDir, isShellSafe } = require("./ponytail-config");
+const { getPonytailInstructions } = require("./ponytail-instructions");
+const {
+  clearMode,
+  isCodex,
+  isCopilot,
+  setMode,
+  writeHookOutput
+} = require("./ponytail-runtime");
+const claudeDir = getClaudeDir();
+const settingsPath = path.join(claudeDir, "settings.json");
+const mode = getDefaultMode();
+if (mode === "off") {
+  clearMode();
+  const hookOutput = isCodex || isCopilot ? "" : "OK";
+  writeHookOutput("SessionStart", "off", hookOutput);
+  process.exit(0);
+}
+try {
+  setMode(mode);
+} catch (e) {}
+let output = getPonytailInstructions(mode);
+if (!isCodex && !isCopilot)
+  try {
+    let hasStatusline = false;
+    if (fs.existsSync(settingsPath)) {
+      const raw = fs.readFileSync(settingsPath, "utf8").replace(/^\uFEFF/, "");
+      const settings = JSON.parse(raw);
+      if (settings.statusLine) {
+        hasStatusline = true;
+      }
+    }
+    const nudgeFlagPath = path.join(claudeDir, ".ponytail-statusline-nudged");
+    if (!hasStatusline && !fs.existsSync(nudgeFlagPath)) {
+      try {
+        fs.writeFileSync(nudgeFlagPath, "");
+      } catch (e) {}
+      const isWindows = process.platform === "win32";
+      const scriptName = isWindows ? "ponytail-statusline.ps1" : "ponytail-statusline.sh";
+      const scriptPath = path.join(__dirname, scriptName);
+      if (isShellSafe(scriptPath)) {
+        const command = isWindows ? `powershell -ExecutionPolicy Bypass -File "${scriptPath}"` : `bash "${scriptPath}"`;
+        const statusLineSnippet = '"statusLine": { "type": "command", "command": ' + JSON.stringify(command) + " }";
+        output += `
+
+` + "STATUSLINE SETUP NEEDED: The ponytail plugin includes a statusline badge showing active mode " + "(e.g. [PONYTAIL], [PONYTAIL:ULTRA]). It is not configured yet. " + "To enable, add this to " + settingsPath + ": " + statusLineSnippet + " " + "Proactively offer to set this up for the user on first interaction.";
+      } else {
+        output += `
+
+` + "STATUSLINE SETUP NEEDED: The ponytail plugin includes a statusline badge showing active mode. " + "Its install path contains characters unsafe to embed in a shell command, so configure it manually: " + 'add a statusLine command of type "command" that runs ' + scriptName + " from the plugin's hooks directory to " + settingsPath + ", quoting/escaping the path for your shell. " + "Proactively offer to set this up for the user on first interaction.";
+      }
+    }
+  } catch (e) {}
+try {
+  writeHookOutput("SessionStart", mode, output);
+} catch (e) {}

package/extensions/dm-ponytail/hooks/ponytail-config.js

@@ -0,0 +1,116 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const DEFAULT_MODE = "full";
+const VALID_MODES = ["off", "lite", "full", "ultra", "review"];
+const RUNTIME_MODES = ["off", "lite", "full", "ultra"];
+function normalizeMode(mode) {
+  if (typeof mode !== "string")
+    return null;
+  const normalized = mode.trim().toLowerCase();
+  return RUNTIME_MODES.includes(normalized) ? normalized : null;
+}
+function normalizeConfigMode(mode) {
+  if (typeof mode !== "string")
+    return null;
+  const normalized = mode.trim().toLowerCase();
+  return VALID_MODES.includes(normalized) ? normalized : null;
+}
+function normalizePersistedMode(mode) {
+  return normalizeMode(mode) || normalizeConfigMode(mode);
+}
+function isDeactivationCommand(text) {
+  const t = String(text || "").trim().toLowerCase().replace(/[.!?\s]+$/, "");
+  return t === "stop ponytail" || t === "normal mode";
+}
+function isShellSafe(p) {
+  return typeof p === "string" && /^[A-Za-z0-9 _.\-:/\\~]+$/.test(p);
+}
+function getConfigDir() {
+  if (process.env.XDG_CONFIG_HOME) {
+    return path.join(process.env.XDG_CONFIG_HOME, "ponytail");
+  }
+  if (process.platform === "win32") {
+    return path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), "ponytail");
+  }
+  return path.join(os.homedir(), ".config", "ponytail");
+}
+function getConfigPath() {
+  return path.join(getConfigDir(), "config.json");
+}
+function getClaudeDir() {
+  return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+}
+function getDefaultMode() {
+  const envMode = process.env.PONYTAIL_DEFAULT_MODE;
+  if (envMode && RUNTIME_MODES.includes(envMode.toLowerCase())) {
+    return envMode.toLowerCase();
+  }
+  try {
+    const configPath = getConfigPath();
+    const config = JSON.parse(fs.readFileSync(configPath, "utf8").replace(/^\uFEFF/, ""));
+    if (config.defaultMode && RUNTIME_MODES.includes(config.defaultMode.toLowerCase())) {
+      return config.defaultMode.toLowerCase();
+    }
+  } catch (e) {}
+  return DEFAULT_MODE;
+}
+function getQuietStartup() {
+  const env = process.env.PONYTAIL_QUIET_STARTUP;
+  if (env !== undefined) {
+    const v = env.trim().toLowerCase();
+    return v !== "" && v !== "0" && v !== "false" && v !== "no";
+  }
+  try {
+    const config = JSON.parse(fs.readFileSync(getConfigPath(), "utf8").replace(/^\uFEFF/, ""));
+    return config.quietStartup === true;
+  } catch (_) {
+    return false;
+  }
+}
+function getHideStatus() {
+  const env = process.env.PONYTAIL_HIDE_STATUS;
+  if (env !== undefined) {
+    const v = env.trim().toLowerCase();
+    return v !== "" && v !== "0" && v !== "false" && v !== "no";
+  }
+  try {
+    const config = JSON.parse(fs.readFileSync(getConfigPath(), "utf8").replace(/^\uFEFF/, ""));
+    return config.hideStatus === true;
+  } catch (_) {
+    return false;
+  }
+}
+function writeDefaultMode(mode) {
+  const normalized = normalizeMode(mode);
+  if (!normalized)
+    return null;
+  const configPath = getConfigPath();
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  let config = {};
+  try {
+    config = JSON.parse(fs.readFileSync(configPath, "utf8").replace(/^\uFEFF/, ""));
+    if (!config || typeof config !== "object" || Array.isArray(config))
+      config = {};
+  } catch (_) {}
+  config.defaultMode = normalized;
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+  return normalized;
+}
+module.exports = {
+  DEFAULT_MODE,
+  VALID_MODES,
+  RUNTIME_MODES,
+  getDefaultMode,
+  getConfigDir,
+  getConfigPath,
+  getClaudeDir,
+  getHideStatus,
+  getQuietStartup,
+  isShellSafe,
+  normalizeMode,
+  normalizeConfigMode,
+  normalizePersistedMode,
+  isDeactivationCommand,
+  writeDefaultMode
+};

package/extensions/dm-ponytail/hooks/ponytail-instructions.js

@@ -0,0 +1,81 @@
+var __dirname = "/Users/que/Projects/dm/dm-mono/packages/coding-agent/dist/extensions/dm-ponytail/hooks";
+const fs = require("fs");
+const path = require("path");
+const { DEFAULT_MODE, normalizeMode, normalizePersistedMode } = require("./ponytail-config");
+const INDEPENDENT_MODES = new Set(["review"]);
+const SKILL_PATH = path.join(__dirname, "..", "skills", "ponytail", "SKILL.md");
+function filterSkillBodyForMode(body, mode) {
+  const effectiveMode = normalizeMode(mode) || DEFAULT_MODE;
+  const withoutFrontmatter = String(body || "").replace(/^---[\s\S]*?---\s*/, "");
+  return withoutFrontmatter.split(/\r?\n/).filter((line) => {
+    const tableLabel = line.match(/^\|\s*\*\*(.+?)\*\*\s*\|/);
+    if (tableLabel) {
+      const labelMode = normalizeMode(tableLabel[1].trim());
+      if (labelMode)
+        return labelMode === effectiveMode;
+    }
+    const exampleLabel = line.match(/^-\s*([^:]+):\s*"/);
+    if (exampleLabel) {
+      const labelMode = normalizeMode(exampleLabel[1].trim());
+      if (labelMode)
+        return labelMode === effectiveMode;
+    }
+    return true;
+  }).join(`
+`);
+}
+function getFallbackInstructions(mode) {
+  return "PONYTAIL MODE ACTIVE — level: " + mode + `
+
+` + `You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.
+
+` + `## Persistence
+
+` + `ACTIVE EVERY RESPONSE. No drift back to over-building. Still active if unsure. Off only: "stop ponytail" / "normal mode".
+
+` + "Current level: **" + mode + "**. Switch: `/ponytail lite|full|ultra`.\n\n" + `## The ladder
+
+` + `Before any code, stop at the first rung that holds (the ladder runs after you understand the problem, not instead of it — read the code it touches and trace the real flow first):
+` + `1. Does this need to be built at all? (YAGNI)
+` + `2. Does it already exist in this codebase? Reuse what is already here, do not re-write it.
+` + `3. Does the standard library do this? Use it.
+` + `4. Does a native platform feature cover it? Use it.
+` + `5. Does an already-installed dependency solve it? Use it.
+` + `6. Can this be one line? Make it one line.
+` + `7. Only then: write the minimum code that works.
+
+` + `Bug fix = root cause, not symptom: grep every caller of the function you touch and fix the shared function once (a smaller diff than one guard per caller); patching only the path the ticket names leaves a sibling caller broken.
+
+` + `## Rules
+
+` + "No abstractions that were not requested. No avoidable dependencies. No boilerplate nobody asked for. " + "Deletion over addition. Boring over clever. Fewest files possible. " + "Ship the lazy version and question the complex request in the same response — never stall. " + "Between two same-size stdlib options, pick the one correct on edge cases. " + "Mark deliberate simplifications that cut a real corner with a known ceiling, using a `ponytail:` comment that names the ceiling and upgrade path.\n\n" + `## Output
+
+` + "Code first. Then at most three short lines: what was skipped, when to add it. " + "If the explanation is longer than the code, delete the explanation. " + `Explanation the user explicitly asked for is not debt, give it in full.
+
+` + `## When NOT to be lazy
+
+` + "Never simplify away: understanding the problem (read it fully and trace the real flow before picking a rung — a small diff you do not understand is just laziness dressed up as efficiency), input validation at trust boundaries, error handling that prevents data loss, " + "security measures, accessibility basics, the calibration real hardware needs (the platform is never the spec ideal), anything the user explicitly asked to keep. " + `Lazy code without its check is unfinished: non-trivial logic leaves ONE runnable check behind (assert-based demo/self-check or one small test file; no frameworks). Trivial one-liners need no test.
+
+` + `## Boundaries
+
+` + 'Ponytail governs what you build, not how you talk. "stop ponytail" or "normal mode": revert. Level persists until changed or session end.';
+}
+function getPonytailInstructions(mode) {
+  const configuredMode = normalizePersistedMode(mode) || DEFAULT_MODE;
+  if (INDEPENDENT_MODES.has(configuredMode)) {
+    return "PONYTAIL MODE ACTIVE — level: " + configuredMode + ". Behavior defined by /ponytail-" + configuredMode + " skill.";
+  }
+  const effectiveMode = normalizeMode(configuredMode) || DEFAULT_MODE;
+  try {
+    return "PONYTAIL MODE ACTIVE — level: " + effectiveMode + `
+
+` + filterSkillBodyForMode(fs.readFileSync(SKILL_PATH, "utf8"), effectiveMode);
+  } catch (e) {
+    return getFallbackInstructions(effectiveMode);
+  }
+}
+module.exports = {
+  filterSkillBodyForMode,
+  getFallbackInstructions,
+  getPonytailInstructions
+};

package/extensions/dm-ponytail/hooks/ponytail-mode-tracker.js

@@ -0,0 +1,96 @@
+const { getDefaultMode, isDeactivationCommand, writeDefaultMode } = require("./ponytail-config");
+const { clearMode, isQoder, readMode, setMode, writeHookOutput } = require("./ponytail-runtime");
+const { getPonytailInstructions } = require("./ponytail-instructions");
+let input = "";
+let done = false;
+function finish() {
+  if (done)
+    return;
+  done = true;
+  try {
+    const data = JSON.parse(input.replace(/^\uFEFF/, ""));
+    const prompt = (data.prompt || "").trim().toLowerCase();
+    let modeSwitched = false;
+    let deactivated = false;
+    if (/^[/@$]ponytail/.test(prompt)) {
+      const parts = prompt.split(/\s+/);
+      const cmd = parts[0].replace(/^[@$]/, "/");
+      const arg = parts[1] || "";
+      let mode = null;
+      let isReportOnly = false;
+      if (cmd === "/ponytail-review" || cmd === "/ponytail:ponytail-review") {
+        mode = "review";
+      } else if (cmd === "/ponytail" || cmd === "/ponytail:ponytail") {
+        if (arg === "default") {
+          const dmode = parts[2];
+          if (dmode === "off" || dmode === "lite" || dmode === "full" || dmode === "ultra") {
+            writeDefaultMode(dmode);
+            writeHookOutput("UserPromptSubmit", dmode, "PONYTAIL DEFAULT SET — new sessions start in " + dmode + ".");
+          }
+          return;
+        }
+        if (arg === "lite")
+          mode = "lite";
+        else if (arg === "full")
+          mode = "full";
+        else if (arg === "ultra")
+          mode = "ultra";
+        else if (arg === "off")
+          mode = "off";
+        else if (arg === "") {
+          isReportOnly = true;
+          mode = readMode() || getDefaultMode();
+        } else {
+          mode = getDefaultMode();
+        }
+      }
+      if (isReportOnly) {
+        writeHookOutput("UserPromptSubmit", mode, "PONYTAIL MODE ACTIVE — level: " + mode);
+      } else if (mode && mode !== "off") {
+        setMode(mode);
+        modeSwitched = true;
+        if (!isQoder) {
+          writeHookOutput("UserPromptSubmit", mode, "PONYTAIL MODE CHANGED — level: " + mode);
+        }
+      } else if (mode === "off") {
+        clearMode();
+        deactivated = true;
+        writeHookOutput("UserPromptSubmit", "off", "PONYTAIL MODE OFF");
+      }
+    }
+    if (!modeSwitched && !deactivated && isDeactivationCommand(prompt)) {
+      clearMode();
+      deactivated = true;
+      writeHookOutput("UserPromptSubmit", "off", "PONYTAIL MODE OFF");
+    }
+    if (isQoder && !deactivated) {
+      let currentMode = readMode();
+      if (!currentMode) {
+        currentMode = getDefaultMode();
+        if (currentMode !== "off") {
+          try {
+            setMode(currentMode);
+          } catch (e) {}
+        }
+      }
+      if (currentMode && currentMode !== "off") {
+        const header = modeSwitched ? "PONYTAIL MODE CHANGED — level: " + currentMode + `
+
+` : "";
+        writeHookOutput("UserPromptSubmit", currentMode, header + getPonytailInstructions(currentMode));
+      }
+    }
+  } catch (e) {}
+}
+process.stdin.on("data", (chunk) => {
+  input += chunk;
+});
+process.stdin.on("end", finish);
+process.stdin.on("error", () => {
+  finish();
+  process.exit(0);
+});
+setTimeout(() => {
+  finish();
+  process.exit(0);
+}, 1000).unref();

package/extensions/dm-ponytail/hooks/ponytail-runtime.js

@@ -0,0 +1,79 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { getClaudeDir, getConfigDir } = require("./ponytail-config");
+const STATE_FILE = ".ponytail-active";
+function isVsCodeCopilotRoot(pluginRoot) {
+  if (!pluginRoot)
+    return false;
+  return pluginRoot.split(/[\\/]+/).includes("agent-plugins") && pluginRoot.toLowerCase().includes(".vscode");
+}
+const isCopilot = Boolean(process.env.COPILOT_PLUGIN_DATA) || isVsCodeCopilotRoot(process.env.CLAUDE_PLUGIN_ROOT);
+const isCodex = !isCopilot && Boolean(process.env.PLUGIN_DATA);
+const isQoder = !isCopilot && !isCodex && Boolean(process.env.QODER_SESSION_ID);
+let stateDir = getClaudeDir();
+if (isCodex)
+  stateDir = process.env.PLUGIN_DATA;
+if (isCopilot)
+  stateDir = process.env.COPILOT_PLUGIN_DATA || getClaudeDir();
+if (isQoder)
+  stateDir = path.join(os.homedir(), ".qoder");
+const statePath = path.join(stateDir, STATE_FILE);
+function setMode(mode) {
+  fs.mkdirSync(path.dirname(statePath), { recursive: true });
+  fs.writeFileSync(statePath, mode);
+}
+function clearMode() {
+  try {
+    fs.unlinkSync(statePath);
+  } catch (e) {}
+}
+function readMode() {
+  try {
+    return fs.readFileSync(statePath, "utf8").trim() || null;
+  } catch (e) {
+    return null;
+  }
+}
+function writeHookOutput(event, mode, context = "") {
+  if (isCopilot) {
+    process.stdout.write(JSON.stringify(event === "SessionStart" && context ? { additionalContext: context } : {}));
+    return;
+  }
+  if (isCodex) {
+    const output = { systemMessage: `PONYTAIL:${mode.toUpperCase()}` };
+    if (context) {
+      output.hookSpecificOutput = {
+        hookEventName: event,
+        additionalContext: context
+      };
+    }
+    process.stdout.write(JSON.stringify(output));
+    return;
+  }
+  if (isQoder) {
+    const output = {};
+    if (context) {
+      output.hookSpecificOutput = {
+        hookEventName: event,
+        additionalContext: context
+      };
+    }
+    process.stdout.write(JSON.stringify(output));
+    return;
+  }
+  if (event === "SubagentStart") {
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: event, additionalContext: context } }));
+    return;
+  }
+  process.stdout.write(context);
+}
+module.exports = {
+  clearMode,
+  isCodex,
+  isCopilot,
+  isQoder,
+  readMode,
+  setMode,
+  writeHookOutput
+};