@yakcc/cli 0.5.0-alpha.0 → 0.5.0-alpha.1

package/dist/index.js

@@ -76,6 +76,16 @@ function byteSwap32(arr) {
   }
   return arr;
 }
+function bytesToHex(bytes) {
+  abytes(bytes);
+  if (hasHexBuiltin)
+    return bytes.toHex();
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += hexes[bytes[i]];
+  }
+  return hex;
+}
 function createHasher(hashCons, info = {}) {
   const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
   const tmp = hashCons(void 0);
@@ -86,13 +96,18 @@ function createHasher(hashCons, info = {}) {
   Object.assign(hashC, info);
   return Object.freeze(hashC);
 }
-var isLE, swap8IfBE, swap32IfBE;
+var isLE, swap8IfBE, swap32IfBE, hasHexBuiltin, hexes;
 var init_utils = __esm({
   "../../node_modules/.pnpm/@noble+hashes@2.2.0/node_modules/@noble/hashes/utils.js"() {
     "use strict";
     isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
     swap8IfBE = isLE ? (n) => n : (n) => byteSwap(n) >>> 0;
     swap32IfBE = isLE ? (u) => u : byteSwap32;
+    hasHexBuiltin = /* @__PURE__ */ (() => (
+      // @ts-ignore
+      typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
+    ))();
+    hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
   }
 });
 
@@ -681,7 +696,7 @@ __export(contract_id_exports, {
 });
 function contractIdFromBytes(canonical) {
   const digest = blake3(canonical);
-  return bytesToHex(digest);
+  return bytesToHex2(digest);
 }
 function contractId(spec) {
   return contractIdFromBytes(canonicalize(spec));
@@ -689,7 +704,7 @@ function contractId(spec) {
 function isValidContractId(s) {
   return /^[0-9a-f]{64}$/.test(s);
 }
-function bytesToHex(bytes) {
+function bytesToHex2(bytes) {
   return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 var init_contract_id = __esm({
@@ -928,13 +943,13 @@ function concatBytes(...arrays) {
   }
   return out;
 }
-function bytesToHex2(bytes) {
+function bytesToHex3(bytes) {
   return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 function specHash(spec) {
   const bytes = canonicalize(spec);
   const digest = blake3(bytes);
-  return bytesToHex2(digest);
+  return bytesToHex3(digest);
 }
 function blockMerkleRoot(triplet) {
   if (triplet.kind === "foreign") {
@@ -960,7 +975,7 @@ function blockMerkleRootLocal(triplet) {
   const proofRootBytes = blake3(proofInput);
   const rootInput = concatBytes(specHashBytes, implHashBytes, proofRootBytes);
   const rootBytes = blake3(rootInput);
-  return bytesToHex2(rootBytes);
+  return bytesToHex3(rootBytes);
 }
 function blockMerkleRootForeign(triplet) {
   const identityObj = {
@@ -972,7 +987,7 @@ function blockMerkleRootForeign(triplet) {
   };
   const identityBytes = canonicalize(identityObj);
   const rootBytes = blake3(identityBytes);
-  return bytesToHex2(rootBytes);
+  return bytesToHex3(rootBytes);
 }
 function isLocalTriplet(t) {
   return t.kind !== "foreign";
@@ -992,7 +1007,7 @@ var init_merkle = __esm({
 
 // ../contracts/dist/canonical-ast.js
 import { Project, ScriptKind, SyntaxKind, ts } from "ts-morph";
-function bytesToHex3(bytes) {
+function bytesToHex4(bytes) {
   return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 function findEnclosingNode(file, range) {
@@ -1133,7 +1148,7 @@ function canonicalAstHash(source, sourceRange) {
   const renames = collectLocalRenames(root);
   const canonical = emitCanonical(root, renames);
   const digest = blake3(TEXT_ENCODER3.encode(canonical));
-  return bytesToHex3(digest);
+  return bytesToHex4(digest);
 }
 var CanonicalAstParseError, TEXT_ENCODER3;
 var init_canonical_ast = __esm({
@@ -2226,7 +2241,7 @@ function isStricterThan(aRoot, bRoot, edgeSet, allRoots) {
   }
   return false;
 }
-function bytesToHex4(bytes) {
+function bytesToHex5(bytes) {
   let hex = "";
   for (let i = 0; i < bytes.length; i++) {
     hex += bytes[i]?.toString(16).padStart(2, "0");
@@ -2858,7 +2873,7 @@ var init_storage = __esm({
          ORDER BY b.block_merkle_root ASC`).all();
         if (blockRows.length === 0)
           return [];
-        const EMPTY_SENTINEL = bytesToHex4(blake3(new Uint8Array(0)));
+        const EMPTY_SENTINEL = bytesToHex5(blake3(new Uint8Array(0)));
         const allRoots = blockRows.map((r) => r.block_merkle_root);
         const placeholders = allRoots.map(() => "?").join(", ");
         const artifactRows = this.db.prepare(`SELECT block_merkle_root, path, bytes
@@ -2872,7 +2887,7 @@ var init_storage = __esm({
             entry = { implSourceHash: EMPTY_SENTINEL, manifestJsonHash: EMPTY_SENTINEL };
             hashMap.set(row.block_merkle_root, entry);
           }
-          const digest = bytesToHex4(blake3(new Uint8Array(row.bytes)));
+          const digest = bytesToHex5(blake3(new Uint8Array(row.bytes)));
           if (row.path === "impl.ts") {
             entry.implSourceHash = digest;
           } else if (row.path === "proof/manifest.json") {
@@ -2911,7 +2926,7 @@ var init_storage = __esm({
         if (entry.workspacePath.startsWith("/") || entry.workspacePath.includes("..")) {
           throw new Error(`storeWorkspacePlumbing: workspacePath must be workspace-relative and must not contain '..': ${entry.workspacePath}`);
         }
-        const actualHash = bytesToHex4(blake3(entry.contentBytes));
+        const actualHash = bytesToHex5(blake3(entry.contentBytes));
         if (actualHash !== entry.contentHash) {
           throw new Error(`storeWorkspacePlumbing: contentHash mismatch for ${entry.workspacePath}: stored=${entry.contentHash}, computed=${actualHash}`);
         }
@@ -2962,7 +2977,7 @@ var init_storage = __esm({
         if (entry.sourceFile.startsWith("/") || entry.sourceFile.includes("..")) {
           throw new Error(`storeSourceFileGlue: sourceFile must be workspace-relative and must not contain '..': ${entry.sourceFile}`);
         }
-        const actualHash = bytesToHex4(blake3(entry.contentBlob));
+        const actualHash = bytesToHex5(blake3(entry.contentBlob));
         if (actualHash !== entry.contentHash) {
           throw new Error(`storeSourceFileGlue: contentHash mismatch for ${entry.sourceFile}: stored=${entry.contentHash}, computed=${actualHash}`);
         }
@@ -3887,11 +3902,11 @@ async function serveRegistry(registry, options) {
       console.error("[serveRegistry] Unhandled request error:", err);
     });
   });
-  await new Promise((resolve6, reject) => {
+  await new Promise((resolve7, reject) => {
     server.once("error", reject);
     server.listen(port, host, () => {
       server.removeListener("error", reject);
-      resolve6();
+      resolve7();
     });
   });
   const address = server.address();
@@ -3908,16 +3923,16 @@ async function serveRegistry(registry, options) {
       if (closed)
         return Promise.resolve();
       closed = true;
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         server.close((err) => {
           if (err !== void 0) {
             if (err.code === "ERR_SERVER_NOT_RUNNING") {
-              resolve6();
+              resolve7();
             } else {
               reject(err);
             }
           } else {
-            resolve6();
+            resolve7();
           }
         });
       });
@@ -4017,11 +4032,11 @@ async function runFederationServe(argv, logger, opts) {
   if (opts?.noBlock === true) {
     return { code: 0, handle };
   }
-  await new Promise((resolve6) => {
+  await new Promise((resolve7) => {
     const shutdown = () => {
       handle.close().then(() => {
-        registry.close().finally(resolve6);
-      }).catch(resolve6);
+        registry.close().finally(resolve7);
+      }).catch(resolve7);
     };
     process.once("SIGINT", shutdown);
     process.once("SIGTERM", shutdown);
@@ -4236,18 +4251,18 @@ function byteSwap322(arr) {
   return arr;
 }
 var swap32IfBE2 = isLE2 ? (u) => u : byteSwap322;
-var hasHexBuiltin = /* @__PURE__ */ (() => (
+var hasHexBuiltin2 = /* @__PURE__ */ (() => (
   // @ts-ignore
   typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
 ))();
-var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-function bytesToHex5(bytes) {
+var hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex6(bytes) {
   abytes2(bytes);
-  if (hasHexBuiltin)
+  if (hasHexBuiltin2)
     return bytes.toHex();
   let hex = "";
   for (let i = 0; i < bytes.length; i++) {
-    hex += hexes[bytes[i]];
+    hex += hexes2[bytes[i]];
   }
   return hex;
 }
@@ -4645,7 +4660,7 @@ async function renameWithRetry(src, dst) {
       }
       if (attempt < MAX_ATTEMPTS - 1) {
         const delay = BACKOFF_MS[attempt] ?? BACKOFF_MS[BACKOFF_MS.length - 1] ?? 160;
-        await new Promise((resolve6) => setTimeout(resolve6, delay));
+        await new Promise((resolve7) => setTimeout(resolve7, delay));
       }
     }
   }
@@ -4706,12 +4721,12 @@ function normalizeSource(s) {
 var encoder = new TextEncoder();
 function sourceHash(unitSource) {
   const normalized = normalizeSource(unitSource);
-  return bytesToHex5(blake32(encoder.encode(normalized)));
+  return bytesToHex6(blake32(encoder.encode(normalized)));
 }
 function keyFromIntentInputs(inputs) {
   const { sourceHash: sh, modelTag, promptVersion, schemaVersion } = inputs;
   const raw = `${sh}\0${modelTag}\0${promptVersion}\0${schemaVersion}`;
-  return bytesToHex5(blake32(encoder.encode(raw)));
+  return bytesToHex6(blake32(encoder.encode(raw)));
 }
 
 // ../shave/dist/corpus/ai-derived.js
@@ -4751,7 +4766,7 @@ async function extractFromAiDerivedCached(intentCard, source, cacheDir, model, p
   if (cached === void 0)
     return void 0;
   const bytes = encoder2.encode(cached.content);
-  const contentHash = bytesToHex5(blake32(bytes));
+  const contentHash = bytesToHex6(blake32(bytes));
   void intentCard;
   return {
     source: "ai-derived",
@@ -4783,7 +4798,7 @@ async function extractFromPropsFile(propsFilePath, _intentCard, source) {
     return void 0;
   }
   const bytes = encoder3.encode(fileContent);
-  const contentHash = bytesToHex5(blake32(bytes));
+  const contentHash = bytesToHex6(blake32(bytes));
   return {
     source: "props-file",
     bytes,
@@ -4908,7 +4923,7 @@ function extractFromDocumentedUsage(intentCard, source) {
 `);
   }
   const bytes = encoder4.encode(content);
-  const contentHash = bytesToHex5(blake32(bytes));
+  const contentHash = bytesToHex6(blake32(bytes));
   return {
     source: "documented-usage",
     bytes,
@@ -4985,7 +5000,7 @@ var UPSTREAM_TEST_PATH = "property-tests.fast-check.ts";
 function extractFromUpstreamTest(intentCard, source) {
   const content = buildUpstreamTestContent(intentCard, source);
   const bytes = encoder5.encode(content);
-  const contentHash = bytesToHex5(blake32(bytes));
+  const contentHash = bytesToHex6(blake32(bytes));
   return {
     source: "upstream-test",
     bytes,
@@ -5505,7 +5520,7 @@ function safeCanonicalAstHash(node, nodeSource, fullSource, start, end) {
       return canonicalAstHash(fullSource, { start, end });
     } catch {
       const TEXT_ENC = new TextEncoder();
-      return bytesToHex5(blake32(TEXT_ENC.encode(nodeSource)));
+      return bytesToHex6(blake32(TEXT_ENC.encode(nodeSource)));
     }
   }
 }
@@ -6906,9 +6921,9 @@ async function extractIntent(unitSource, ctx) {
     } catch (err) {
       console.warn(`[shave extractIntent] Corrupt cache entry for key ${cacheKey} (${err instanceof Error ? err.message : String(err)}); treating as miss.`);
       const { unlink: unlink2 } = await import("fs/promises");
-      const { join: join20 } = await import("path");
+      const { join: join24 } = await import("path");
       const shard = cacheKey.slice(0, 3);
-      const filePath = join20(ctx.cacheDir, shard, `${cacheKey}.json`);
+      const filePath = join24(ctx.cacheDir, shard, `${cacheKey}.json`);
       await unlink2(filePath).catch(() => {
       });
     }
@@ -8860,18 +8875,411 @@ async function compile(argv, logger, opts) {
 // src/index.ts
 init_federation();
 
-// src/commands/hooks-aider-install.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync4 } from "fs";
+// ../hooks-base/dist/telemetry.js
+init_blake3();
+init_utils();
+import { appendFileSync as appendFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync6 } from "fs";
 import { homedir } from "os";
-import { join as join10 } from "path";
+import { join as join13 } from "path";
+
+// ../hooks-base/dist/telemetry-sink.js
+import { appendFileSync, mkdirSync as mkdirSync5 } from "fs";
+import { join as join11 } from "path";
+
+// ../hooks-base/dist/telemetry-config.js
+var DEFAULT_TELEMETRY_ENDPOINT = "https://metrics.yakcc.com";
+function resolveTelemetryConfig(env = process.env) {
+  const fullIntent = env.YAKCC_TELEMETRY_FULL_INTENT === "1";
+  if (env.YAKCC_TELEMETRY_DISABLED === "1") {
+    return { disabled: true, endpoint: DEFAULT_TELEMETRY_ENDPOINT, fullIntent };
+  }
+  const rawEndpoint = env.YAKCC_TELEMETRY_ENDPOINT;
+  if (rawEndpoint === "off") {
+    return { disabled: true, endpoint: DEFAULT_TELEMETRY_ENDPOINT, fullIntent };
+  }
+  const endpoint = rawEndpoint !== void 0 && rawEndpoint !== "" ? rawEndpoint : DEFAULT_TELEMETRY_ENDPOINT;
+  return { disabled: false, endpoint, fullIntent };
+}
+
+// ../hooks-base/dist/telemetry-wire.js
+import { readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname6, join as join10, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var SCHEMA_VERSION2 = 1;
+var _cachedSource = null;
+function buildSource() {
+  if (_cachedSource !== null)
+    return _cachedSource;
+  let cliVersion = "unknown";
+  try {
+    const __filename = fileURLToPath2(import.meta.url);
+    const pkgPath = resolve3(join10(dirname6(__filename), "../package.json"));
+    const pkgJson = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+    cliVersion = typeof pkgJson.version === "string" ? pkgJson.version : "unknown";
+  } catch {
+  }
+  _cachedSource = {
+    cliVersion,
+    platform: process.platform,
+    nodeVersion: process.version
+  };
+  return _cachedSource;
+}
+function buildEnvelope(events, sessionId, now = Date.now()) {
+  return {
+    schemaVersion: SCHEMA_VERSION2,
+    sessionId,
+    events,
+    emittedAt: now,
+    source: buildSource()
+  };
+}
+
+// ../hooks-base/dist/telemetry-sink.js
+var _SINK_FALLBACK_SESSION_ID = (() => {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.floor(Math.random() * 16);
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+})();
+function _resolveSinkSessionId() {
+  return process.env.CLAUDE_SESSION_ID ?? _SINK_FALLBACK_SESSION_ID;
+}
+var NoOpSink = class {
+  send(_event) {
+  }
+};
+var FileSink = class {
+  dir;
+  sessionId;
+  initialized = false;
+  // at-most-once warn set (DEC-TELEMETRY-EXPORT-FAIL-SILENT-005)
+  warnedClasses = /* @__PURE__ */ new Set();
+  constructor(dir, sessionId) {
+    this.dir = dir;
+    this.sessionId = sessionId ?? _resolveSinkSessionId();
+  }
+  send(event) {
+    try {
+      if (!this.initialized) {
+        mkdirSync5(this.dir, { recursive: true });
+        this.initialized = true;
+      }
+      const filePath = join11(this.dir, `${this.sessionId}.jsonl`);
+      appendFileSync(filePath, `${JSON.stringify(event)}
+`, "utf-8");
+    } catch (err) {
+      this._warnOnce(err);
+    }
+  }
+  _warnOnce(err) {
+    const cls = err instanceof Error ? err.constructor.name : "UnknownError";
+    if (!this.warnedClasses.has(cls)) {
+      this.warnedClasses.add(cls);
+      console.warn(`[yakcc telemetry] FileSink error (${cls}):`, err);
+    }
+  }
+};
+var BATCH_FLUSH_INTERVAL_MS = 5e3;
+var BATCH_FLUSH_SIZE = 50;
+var FETCH_TIMEOUT_MS = 1e4;
+var HttpsBatcherSink = class {
+  endpoint;
+  sessionId;
+  buffer = [];
+  timer = null;
+  flushing = false;
+  // at-most-once warn set (DEC-TELEMETRY-EXPORT-FAIL-SILENT-005)
+  warnedClasses = /* @__PURE__ */ new Set();
+  _beforeExitHandler;
+  _registered = false;
+  constructor(endpoint, sessionId) {
+    this.endpoint = endpoint;
+    this.sessionId = sessionId ?? _resolveSinkSessionId();
+    this._beforeExitHandler = () => {
+      this._flushSync();
+    };
+  }
+  send(event) {
+    this.buffer.push(event);
+    this._ensureTimer();
+    if (this.buffer.length >= BATCH_FLUSH_SIZE) {
+      this._scheduleFlush();
+    }
+  }
+  /** Start the interval timer and register the beforeExit handler (lazy, once). */
+  _ensureTimer() {
+    if (this._registered)
+      return;
+    this._registered = true;
+    this.timer = setInterval(() => {
+      this._scheduleFlush();
+    }, BATCH_FLUSH_INTERVAL_MS);
+    if (this.timer && typeof this.timer.unref === "function") {
+      this.timer.unref();
+    }
+    process.on("beforeExit", this._beforeExitHandler);
+  }
+  /** Schedule a flush on the next microtask tick (non-blocking). */
+  _scheduleFlush() {
+    if (this.buffer.length === 0)
+      return;
+    const batch = this.buffer.splice(0, this.buffer.length);
+    void this._flush(batch);
+  }
+  /** Async flush — fire-and-forget. DEC-TELEMETRY-EXPORT-FAIL-SILENT-005. */
+  async _flush(batch) {
+    if (batch.length === 0)
+      return;
+    const envelope = buildEnvelope(batch, this.sessionId);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+      const response = await fetch(this.endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": `yakcc-hooks-base/${envelope.source.cliVersion} (${envelope.source.platform}; node-${envelope.source.nodeVersion})`
+        },
+        body: JSON.stringify(envelope),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        this._warnOnce(new Error(`HTTP ${response.status}`), "HttpError");
+      }
+    } catch (err) {
+      this._warnOnce(err);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Best-effort exit-flush called from `beforeExit`.
+   *
+   * @decision DEC-TELEMETRY-EXPORT-BATCHING-004
+   * `beforeExit` fires when the Node event loop becomes empty (not via process.exit()).
+   * We start the async flush here. Because `beforeExit` fires when the loop is empty,
+   * the pending fetch promise keeps the loop alive long enough for the flush to complete
+   * under normal conditions (no explicit process.exit()). If `process.exit()` is called
+   * by the host, inflight events are dropped — this is the documented NG5 behavior
+   * (no retry queue, at-most-once delivery).
+   *
+   * Previous implementation used `Atomics.wait` as a bounded sleep, but
+   * `Atomics.wait` on the main thread throws `TypeError` in Node ≥ 16 when
+   * `--experimental-vm-modules` or other thread guards are active (Node 22 always
+   * rejects it on the main thread). The async-only approach is correct here because
+   * `beforeExit` itself is an async boundary: the outstanding fetch promise will
+   * re-trigger the loop, and if the process exits without the loop draining further,
+   * the events are already acknowledged as best-effort (DEC-TELEMETRY-EXPORT-BATCHING-004).
+   */
+  _flushSync() {
+    if (this.buffer.length === 0)
+      return;
+    if (this.flushing)
+      return;
+    this.flushing = true;
+    const batch = this.buffer.splice(0, this.buffer.length);
+    void this._flush(batch);
+  }
+  /**
+   * Deregister timer and handlers (for tests and clean shutdown).
+   * Drains the buffer without flushing — events in-buffer at dispose time are
+   * dropped (NG5: at-most-once delivery). This is intentional for test isolation:
+   * after dispose(), no further async fetch calls will originate from this sink.
+   */
+  dispose() {
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    process.removeListener("beforeExit", this._beforeExitHandler);
+    this._registered = false;
+    this.buffer.length = 0;
+  }
+  _warnOnce(err, classOverride) {
+    const cls = classOverride ?? (err instanceof Error ? err.constructor.name : "UnknownError");
+    if (!this.warnedClasses.has(cls)) {
+      this.warnedClasses.add(cls);
+      console.warn(`[yakcc telemetry] HttpsBatcherSink error (${cls}):`, err);
+    }
+  }
+};
+var CompositeSink = class {
+  sinks;
+  constructor(sinks) {
+    this.sinks = sinks;
+  }
+  send(event) {
+    for (const sink of this.sinks) {
+      try {
+        sink.send(event);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Propagate dispose() to inner sinks that support it.
+   * Safe to call multiple times (inner sinks are idempotent on dispose).
+   * @internal — for test isolation and clean process shutdown.
+   */
+  dispose() {
+    for (const sink of this.sinks) {
+      if (sink instanceof HttpsBatcherSink) {
+        sink.dispose();
+      }
+    }
+  }
+};
+var _sinkSingleton = null;
+function selectSink(env = process.env, config) {
+  if (_sinkSingleton !== null)
+    return _sinkSingleton;
+  _sinkSingleton = _buildSink(config ?? resolveTelemetryConfig(env));
+  return _sinkSingleton;
+}
+function _buildSink(config, sessionId) {
+  if (config.disabled) {
+    return new NoOpSink();
+  }
+  const endpoint = config.endpoint;
+  if (endpoint.startsWith("file://")) {
+    const dir = endpoint.slice("file://".length);
+    return new FileSink(dir, sessionId);
+  }
+  if (endpoint.startsWith("https://")) {
+    return new CompositeSink([new HttpsBatcherSink(endpoint, sessionId)]);
+  }
+  console.warn(`[yakcc telemetry] Unknown endpoint scheme: ${endpoint} \u2014 using NoOpSink`);
+  return new NoOpSink();
+}
+
+// ../hooks-base/dist/enforcement-config.js
+import { existsSync as existsSync3, readFileSync as readFileSync6 } from "fs";
+import { join as join12 } from "path";
+
+// ../hooks-base/dist/telemetry.js
+var FALLBACK_SESSION_ID = (() => {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.floor(Math.random() * 16);
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+})();
+function resolveSessionId() {
+  return process.env.CLAUDE_SESSION_ID ?? FALLBACK_SESSION_ID;
+}
+function resolveTelemetryDir() {
+  return process.env.YAKCC_TELEMETRY_DIR ?? join13(homedir(), ".yakcc", "telemetry");
+}
+function hashIntent(intentText) {
+  const encoded = new TextEncoder().encode(intentText);
+  const digest = blake3(encoded);
+  return bytesToHex(digest);
+}
+function appendTelemetryEvent(event, sessionId, dir) {
+  if (!existsSync4(dir)) {
+    mkdirSync6(dir, { recursive: true });
+  }
+  const filePath = join13(dir, `${sessionId}.jsonl`);
+  appendFileSync2(filePath, `${JSON.stringify(event)}
+`, "utf-8");
+  try {
+    selectSink().send(event);
+  } catch {
+  }
+}
+
+// src/commands/hook-intercept.ts
+var WINDOWS_ILLEGAL_FILENAME_RE = /[<>:"/\\|?*\x00-\x1f]/;
+function sanitizeSessionId(raw) {
+  if (WINDOWS_ILLEGAL_FILENAME_RE.test(raw)) return null;
+  return raw;
+}
+var ALLOWED_TOOL_NAMES = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit"]);
+async function hookIntercept(argv, logger, options) {
+  void argv;
+  void logger;
+  const stdinStream = options?.stdin ?? process.stdin;
+  const telemetryDir = options?.telemetryDir ?? resolveTelemetryDir();
+  const appendEvent = options?.appendEvent ?? appendTelemetryEvent;
+  const now = options?.now ?? Date.now;
+  const start = now();
+  try {
+    const chunks = [];
+    for await (const chunk of stdinStream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const stdinText = Buffer.concat(chunks).toString("utf-8").trim();
+    if (!stdinText) {
+      return 0;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(stdinText);
+    } catch {
+      return 0;
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+      return 0;
+    }
+    const payload = parsed;
+    const toolName = payload.tool_name;
+    if (typeof toolName !== "string" || !ALLOWED_TOOL_NAMES.has(toolName)) {
+      return 0;
+    }
+    const validToolName = toolName;
+    let sessionId;
+    const payloadSessionId = payload.session_id;
+    if (typeof payloadSessionId === "string" && payloadSessionId.length > 0) {
+      const sanitized = sanitizeSessionId(payloadSessionId);
+      sessionId = sanitized ?? resolveSessionId();
+    } else {
+      sessionId = resolveSessionId();
+    }
+    const toolInput = typeof payload.tool_input === "object" && payload.tool_input !== null ? payload.tool_input : {};
+    const intentText = typeof toolInput.new_string === "string" ? toolInput.new_string : typeof toolInput.content === "string" ? toolInput.content : "";
+    const end = now();
+    const event = {
+      t: end,
+      intentHash: hashIntent(intentText),
+      toolName: validToolName,
+      candidateCount: 0,
+      // Phase 1: no registry query
+      topScore: null,
+      // Phase 1: no registry query
+      substituted: false,
+      // Phase 1: never substitutes
+      substitutedAtomHash: null,
+      // Phase 1: never substitutes
+      latencyMs: end - start,
+      outcome: "passthrough"
+      // D-HOOK-5 canonical value per plan section 3
+    };
+    appendEvent(event, sessionId, telemetryDir);
+  } catch {
+  }
+  return 0;
+}
+
+// src/commands/hooks-aider-install.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync7, readFileSync as readFileSync7, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join14 } from "path";
 import { parseArgs as parseArgs6 } from "util";
 var AIDER_HOOK_MARKER_FILENAME = "yakcc-aider-hook.json";
 var YAKCC_AIDER_MARKER = "yakcc-hook-v1-aider";
 var HOOK_COMMAND = "yakcc hook-intercept";
 function readMarker(markerPath) {
-  if (!existsSync3(markerPath)) return null;
+  if (!existsSync5(markerPath)) return null;
   try {
-    return JSON.parse(readFileSync5(markerPath, "utf-8"));
+    return JSON.parse(readFileSync7(markerPath, "utf-8"));
   } catch {
     return null;
   }
@@ -8896,10 +9304,10 @@ async function hooksAiderInstall(argv, logger, overrideAiderDir) {
     logger.error(`error: ${err.message}`);
     return 1;
   }
-  const aiderDir = overrideAiderDir ?? join10(homedir(), ".aider");
-  const markerPath = join10(aiderDir, AIDER_HOOK_MARKER_FILENAME);
+  const aiderDir = overrideAiderDir ?? join14(homedir2(), ".aider");
+  const markerPath = join14(aiderDir, AIDER_HOOK_MARKER_FILENAME);
   try {
-    mkdirSync5(aiderDir, { recursive: true });
+    mkdirSync7(aiderDir, { recursive: true });
   } catch (err) {
     logger.error(`error: cannot create ${aiderDir}: ${String(err)}`);
     return 1;
@@ -8945,26 +9353,194 @@ async function hooksAiderInstall(argv, logger, overrideAiderDir) {
   return 0;
 }
 
-// src/commands/hooks-cursor-install.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
-import { join as join11 } from "path";
+// src/commands/hooks-cline-install.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync8, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join15 } from "path";
 import { parseArgs as parseArgs7 } from "util";
+var CLINE_HOOK_MARKER_FILENAME = "yakcc-cline-hook.json";
+var YAKCC_CLINE_MARKER = "yakcc-hook-v1-cline";
+var HOOK_COMMAND2 = "yakcc hook-intercept";
+function readMarker2(markerPath) {
+  if (!existsSync6(markerPath)) return null;
+  try {
+    return JSON.parse(readFileSync8(markerPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function isYakccInstalled2(markerPath) {
+  const marker = readMarker2(markerPath);
+  return marker !== null && marker._yakcc === YAKCC_CLINE_MARKER;
+}
+async function hooksClineInstall(argv, logger, overrideClineDir) {
+  let parsed;
+  try {
+    parsed = parseArgs7({
+      args: [...argv],
+      options: {
+        target: { type: "string", short: "t" },
+        uninstall: { type: "boolean" }
+      },
+      allowPositionals: false,
+      strict: true
+    });
+  } catch (err) {
+    logger.error(`error: ${err.message}`);
+    return 1;
+  }
+  const clineDir = overrideClineDir ?? join15(homedir3(), ".config", "cline");
+  const markerPath = join15(clineDir, CLINE_HOOK_MARKER_FILENAME);
+  try {
+    mkdirSync8(clineDir, { recursive: true });
+  } catch (err) {
+    logger.error(`error: cannot create ${clineDir}: ${String(err)}`);
+    return 1;
+  }
+  if (parsed.values.uninstall) {
+    if (!isYakccInstalled2(markerPath)) {
+      logger.log("yakcc cline hook not installed \u2014 nothing to uninstall.");
+      return 0;
+    }
+    try {
+      rmSync2(markerPath);
+    } catch (err) {
+      logger.error(`error: cannot remove ${markerPath}: ${String(err)}`);
+      return 1;
+    }
+    logger.log(`yakcc cline hook marker removed: ${markerPath}`);
+    return 0;
+  }
+  if (isYakccInstalled2(markerPath)) {
+    logger.log(`yakcc cline hook already installed at ${markerPath} (idempotent).`);
+    return 0;
+  }
+  const marker = {
+    command: HOOK_COMMAND2,
+    description: "yakcc tool-call interception hook for Cline",
+    sessionEnvVar: "CLINE_SESSION_ID",
+    telemetryPrefix: "cline",
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    _yakcc: YAKCC_CLINE_MARKER,
+    note: "Cline (saoudrizwan.claude-dev) does not yet expose synchronous tool-call interception via a stable Node.js API. This marker documents the intended wiring (DEC-CLI-HOOKS-CLINE-INSTALL-001). When the Cline extension API stabilises, hook activation requires no reinstall."
+  };
+  try {
+    writeFileSync5(markerPath, `${JSON.stringify(marker, null, 2)}
+`, "utf-8");
+  } catch (err) {
+    logger.error(`error: cannot write marker ${markerPath}: ${String(err)}`);
+    return 1;
+  }
+  logger.log(`yakcc cline hook marker installed: ${markerPath}`);
+  logger.log("note: Cline tool-call interception API not yet stable \u2014 see marker for details.");
+  return 0;
+}
+
+// src/commands/hooks-continue-install.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync9, readFileSync as readFileSync9, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join16 } from "path";
+import { parseArgs as parseArgs8 } from "util";
+var CONTINUE_HOOK_MARKER_FILENAME = "yakcc-continue-hook.json";
+var YAKCC_CONTINUE_MARKER = "yakcc-hook-v1-continue";
+var HOOK_COMMAND3 = "yakcc hook-intercept";
+function readMarker3(markerPath) {
+  if (!existsSync7(markerPath)) return null;
+  try {
+    return JSON.parse(readFileSync9(markerPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function isYakccInstalled3(markerPath) {
+  const marker = readMarker3(markerPath);
+  return marker !== null && marker._yakcc === YAKCC_CONTINUE_MARKER;
+}
+async function hooksContinueInstall(argv, logger, overrideContinueDir) {
+  let parsed;
+  try {
+    parsed = parseArgs8({
+      args: [...argv],
+      options: {
+        target: { type: "string", short: "t" },
+        uninstall: { type: "boolean" }
+      },
+      allowPositionals: false,
+      strict: true
+    });
+  } catch (err) {
+    logger.error(`error: ${err.message}`);
+    return 1;
+  }
+  const continueDir = overrideContinueDir ?? join16(homedir4(), ".continue");
+  const markerPath = join16(continueDir, CONTINUE_HOOK_MARKER_FILENAME);
+  try {
+    mkdirSync9(continueDir, { recursive: true });
+  } catch (err) {
+    logger.error(`error: cannot create ${continueDir}: ${String(err)}`);
+    return 1;
+  }
+  if (parsed.values.uninstall) {
+    if (!isYakccInstalled3(markerPath)) {
+      logger.log("yakcc continue hook not installed \u2014 nothing to uninstall.");
+      return 0;
+    }
+    try {
+      rmSync3(markerPath);
+    } catch (err) {
+      logger.error(`error: cannot remove ${markerPath}: ${String(err)}`);
+      return 1;
+    }
+    logger.log(`yakcc continue hook marker removed: ${markerPath}`);
+    return 0;
+  }
+  if (isYakccInstalled3(markerPath)) {
+    logger.log(`yakcc continue hook already installed at ${markerPath} (idempotent).`);
+    return 0;
+  }
+  const marker = {
+    command: HOOK_COMMAND3,
+    description: "yakcc tool-call interception hook for Continue.dev",
+    sessionEnvVar: "CONTINUE_SESSION_ID",
+    telemetryPrefix: "continue",
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    _yakcc: YAKCC_CONTINUE_MARKER,
+    note: "Continue.dev (continue.continue) does not yet expose synchronous tool-call interception via a stable Node.js API. This marker documents the intended wiring (DEC-CLI-HOOKS-CONTINUE-INSTALL-001). When the Continue.dev API stabilises, hook activation requires no reinstall."
+  };
+  try {
+    writeFileSync6(markerPath, `${JSON.stringify(marker, null, 2)}
+`, "utf-8");
+  } catch (err) {
+    logger.error(`error: cannot write marker ${markerPath}: ${String(err)}`);
+    return 1;
+  }
+  logger.log(`yakcc continue hook marker installed: ${markerPath}`);
+  logger.log(
+    "note: Continue.dev tool-call interception API not yet stable \u2014 see marker for details."
+  );
+  return 0;
+}
+
+// src/commands/hooks-cursor-install.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync10, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
+import { join as join17 } from "path";
+import { parseArgs as parseArgs9 } from "util";
 var CURSOR_HOOK_MARKER_FILENAME = "yakcc-cursor-hook.json";
 var YAKCC_CURSOR_MARKER = "yakcc-hook-v1-cursor";
-var HOOK_COMMAND2 = "yakcc hook-intercept";
+var HOOK_COMMAND4 = "yakcc hook-intercept";
 function readCursorSettings(settingsPath) {
-  if (!existsSync4(settingsPath)) return {};
+  if (!existsSync8(settingsPath)) return {};
   try {
-    return JSON.parse(readFileSync6(settingsPath, "utf-8"));
+    return JSON.parse(readFileSync10(settingsPath, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeCursorSettings(settingsPath, settings) {
-  writeFileSync5(settingsPath, `${JSON.stringify(settings, null, 2)}
+  writeFileSync7(settingsPath, `${JSON.stringify(settings, null, 2)}
 `, "utf-8");
 }
-function isYakccInstalled2(settings) {
+function isYakccInstalled4(settings) {
   const hooks = settings.hooks;
   if (hooks == null || typeof hooks !== "object") return false;
   const yakccEntry = hooks.yakcc;
@@ -8972,7 +9548,7 @@ function isYakccInstalled2(settings) {
   return yakccEntry._yakcc === YAKCC_CURSOR_MARKER;
 }
 function applyInstall(settings) {
-  if (isYakccInstalled2(settings)) {
+  if (isYakccInstalled4(settings)) {
     return { settings, alreadyInstalled: true };
   }
   return {
@@ -8981,7 +9557,7 @@ function applyInstall(settings) {
       hooks: {
         ...settings.hooks ?? {},
         yakcc: {
-          command: HOOK_COMMAND2,
+          command: HOOK_COMMAND4,
           description: "yakcc tool-call interception hook for Cursor",
           sessionEnvVar: "CURSOR_SESSION_ID",
           _yakcc: YAKCC_CURSOR_MARKER
@@ -8992,7 +9568,7 @@ function applyInstall(settings) {
   };
 }
 function applyUninstall(settings) {
-  if (!isYakccInstalled2(settings)) {
+  if (!isYakccInstalled4(settings)) {
     return { settings, wasInstalled: false };
   }
   const { yakcc: _removed, ...remainingHooks } = settings.hooks ?? {};
@@ -9001,7 +9577,7 @@ function applyUninstall(settings) {
   return { settings: newSettings, wasInstalled: true };
 }
 async function hooksCursorInstall(argv, logger) {
-  const { values } = parseArgs7({
+  const { values } = parseArgs9({
     args: [...argv],
     options: {
       target: { type: "string", short: "t" },
@@ -9011,11 +9587,11 @@ async function hooksCursorInstall(argv, logger) {
     strict: true
   });
   const targetDir = values.target ?? ".";
-  const cursorDir = join11(targetDir, ".cursor");
-  const settingsPath = join11(cursorDir, "settings.json");
-  const markerPath = join11(cursorDir, CURSOR_HOOK_MARKER_FILENAME);
+  const cursorDir = join17(targetDir, ".cursor");
+  const settingsPath = join17(cursorDir, "settings.json");
+  const markerPath = join17(cursorDir, CURSOR_HOOK_MARKER_FILENAME);
   try {
-    mkdirSync6(cursorDir, { recursive: true });
+    mkdirSync10(cursorDir, { recursive: true });
   } catch (err) {
     logger.error(`error: cannot create ${cursorDir}: ${String(err)}`);
     return 1;
@@ -9043,11 +9619,11 @@ async function hooksCursorInstall(argv, logger) {
     return 1;
   }
   try {
-    writeFileSync5(
+    writeFileSync7(
       markerPath,
       `${JSON.stringify(
         {
-          command: HOOK_COMMAND2,
+          command: HOOK_COMMAND4,
           description: "yakcc tool-call interception hook for Cursor",
           sessionEnvVar: "CURSOR_SESSION_ID",
           telemetryPrefix: "cursor",
@@ -9067,7 +9643,7 @@ async function hooksCursorInstall(argv, logger) {
     logger.log(`yakcc cursor hook already installed at ${settingsPath} (idempotent).`);
   } else {
     logger.log(`yakcc cursor hook installed at ${settingsPath}`);
-    logger.log(`hook command: ${HOOK_COMMAND2}`);
+    logger.log(`hook command: ${HOOK_COMMAND4}`);
     logger.log("session env var: CURSOR_SESSION_ID");
     logger.log(`marker: ${markerPath}`);
     logger.log("note: Cursor tool-call interception API not yet stable \u2014 see marker for details.");
@@ -9076,27 +9652,27 @@ async function hooksCursorInstall(argv, logger) {
 }
 
 // src/commands/hooks-install.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync7, readFileSync as readFileSync7, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "fs";
-import { join as join12 } from "path";
-import { parseArgs as parseArgs8 } from "util";
+import { existsSync as existsSync9, mkdirSync as mkdirSync11, readFileSync as readFileSync11, rmSync as rmSync4, writeFileSync as writeFileSync8 } from "fs";
+import { join as join18 } from "path";
+import { parseArgs as parseArgs10 } from "util";
 var HOOK_EVENT = "PreToolUse";
 var HOOK_MATCHER = "Edit|Write|MultiEdit";
-var HOOK_COMMAND3 = "yakcc hook-intercept";
+var HOOK_COMMAND5 = "yakcc hook-intercept";
 var YAKCC_MARKER = "yakcc-hook-v1";
 function readSettings(settingsPath) {
-  if (!existsSync5(settingsPath)) return {};
+  if (!existsSync9(settingsPath)) return {};
   try {
-    return JSON.parse(readFileSync7(settingsPath, "utf-8"));
+    return JSON.parse(readFileSync11(settingsPath, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settingsPath, settings) {
-  writeFileSync6(settingsPath, `${JSON.stringify(settings, null, 2)}
+  writeFileSync8(settingsPath, `${JSON.stringify(settings, null, 2)}
 `, "utf-8");
 }
 function buildYakccHookObject() {
-  return { type: "command", command: HOOK_COMMAND3, _yakcc: YAKCC_MARKER };
+  return { type: "command", command: HOOK_COMMAND5, _yakcc: YAKCC_MARKER };
 }
 function isYakccEntry(entry) {
   return entry.hooks.some((h) => h._yakcc === YAKCC_MARKER);
@@ -9135,7 +9711,7 @@ function applyUninstall2(settings) {
   return { settings: newSettings, wasInstalled: true };
 }
 async function hooksClaudeCodeInstall(argv, logger) {
-  const { values } = parseArgs8({
+  const { values } = parseArgs10({
     args: [...argv],
     options: {
       target: { type: "string", short: "t" },
@@ -9145,11 +9721,11 @@ async function hooksClaudeCodeInstall(argv, logger) {
     strict: true
   });
   const targetDir = values.target ?? ".";
-  const claudeDir = join12(targetDir, ".claude");
-  const settingsPath = join12(claudeDir, "settings.json");
-  const claudeMdPath = join12(claudeDir, "CLAUDE.md");
+  const claudeDir = join18(targetDir, ".claude");
+  const settingsPath = join18(claudeDir, "settings.json");
+  const claudeMdPath = join18(claudeDir, "CLAUDE.md");
   try {
-    mkdirSync7(claudeDir, { recursive: true });
+    mkdirSync11(claudeDir, { recursive: true });
   } catch (err) {
     logger.error(`error: cannot create ${claudeDir}: ${String(err)}`);
     return 1;
@@ -9176,9 +9752,9 @@ async function hooksClaudeCodeInstall(argv, logger) {
     logger.error(`error: cannot write ${settingsPath}: ${String(err)}`);
     return 1;
   }
-  if (existsSync5(claudeMdPath)) {
+  if (existsSync9(claudeMdPath)) {
     try {
-      rmSync2(claudeMdPath);
+      rmSync4(claudeMdPath);
     } catch (err) {
       logger.error(`warning: cannot remove v0 stub ${claudeMdPath}: ${String(err)}`);
     }
@@ -9187,31 +9763,31 @@ async function hooksClaudeCodeInstall(argv, logger) {
     logger.log(`yakcc hook already installed at ${settingsPath} (idempotent).`);
   } else {
     logger.log(`yakcc hook installed at ${settingsPath}`);
-    logger.log(`tool-call interception: ${HOOK_MATCHER} \u2192 ${HOOK_COMMAND3}`);
+    logger.log(`tool-call interception: ${HOOK_MATCHER} \u2192 ${HOOK_COMMAND5}`);
   }
   return 0;
 }
 
 // src/commands/hooks-windsurf-install.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
-import { join as join13 } from "path";
-import { parseArgs as parseArgs9 } from "util";
+import { existsSync as existsSync10, mkdirSync as mkdirSync12, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "fs";
+import { join as join19 } from "path";
+import { parseArgs as parseArgs11 } from "util";
 var WINDSURF_HOOK_MARKER_FILENAME = "yakcc-windsurf-hook.json";
 var YAKCC_WINDSURF_MARKER = "yakcc-hook-v1-windsurf";
-var HOOK_COMMAND4 = "yakcc hook-intercept";
+var HOOK_COMMAND6 = "yakcc hook-intercept";
 function readWindsurfSettings(settingsPath) {
-  if (!existsSync6(settingsPath)) return {};
+  if (!existsSync10(settingsPath)) return {};
   try {
-    return JSON.parse(readFileSync8(settingsPath, "utf-8"));
+    return JSON.parse(readFileSync12(settingsPath, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeWindsurfSettings(settingsPath, settings) {
-  writeFileSync7(settingsPath, `${JSON.stringify(settings, null, 2)}
+  writeFileSync9(settingsPath, `${JSON.stringify(settings, null, 2)}
 `, "utf-8");
 }
-function isYakccInstalled3(settings) {
+function isYakccInstalled5(settings) {
   const hooks = settings.hooks;
   if (hooks == null || typeof hooks !== "object") return false;
   const yakccEntry = hooks.yakcc;
@@ -9219,7 +9795,7 @@ function isYakccInstalled3(settings) {
   return yakccEntry._yakcc === YAKCC_WINDSURF_MARKER;
 }
 function applyInstall3(settings) {
-  if (isYakccInstalled3(settings)) {
+  if (isYakccInstalled5(settings)) {
     return { settings, alreadyInstalled: true };
   }
   return {
@@ -9228,7 +9804,7 @@ function applyInstall3(settings) {
       hooks: {
         ...settings.hooks ?? {},
         yakcc: {
-          command: HOOK_COMMAND4,
+          command: HOOK_COMMAND6,
           description: "yakcc tool-call interception hook for Windsurf",
           sessionEnvVar: "WINDSURF_SESSION_ID",
           _yakcc: YAKCC_WINDSURF_MARKER
@@ -9239,7 +9815,7 @@ function applyInstall3(settings) {
   };
 }
 function applyUninstall3(settings) {
-  if (!isYakccInstalled3(settings)) {
+  if (!isYakccInstalled5(settings)) {
     return { settings, wasInstalled: false };
   }
   const { yakcc: _removed, ...remainingHooks } = settings.hooks ?? {};
@@ -9248,7 +9824,7 @@ function applyUninstall3(settings) {
   return { settings: newSettings, wasInstalled: true };
 }
 async function hooksWindsurfInstall(argv, logger) {
-  const { values } = parseArgs9({
+  const { values } = parseArgs11({
     args: [...argv],
     options: {
       target: { type: "string", short: "t" },
@@ -9258,11 +9834,11 @@ async function hooksWindsurfInstall(argv, logger) {
     strict: true
   });
   const targetDir = values.target ?? ".";
-  const windsurfDir = join13(targetDir, ".windsurf");
-  const settingsPath = join13(windsurfDir, "settings.json");
-  const markerPath = join13(windsurfDir, WINDSURF_HOOK_MARKER_FILENAME);
+  const windsurfDir = join19(targetDir, ".windsurf");
+  const settingsPath = join19(windsurfDir, "settings.json");
+  const markerPath = join19(windsurfDir, WINDSURF_HOOK_MARKER_FILENAME);
   try {
-    mkdirSync8(windsurfDir, { recursive: true });
+    mkdirSync12(windsurfDir, { recursive: true });
   } catch (err) {
     logger.error(`error: cannot create ${windsurfDir}: ${String(err)}`);
     return 1;
@@ -9290,11 +9866,11 @@ async function hooksWindsurfInstall(argv, logger) {
     return 1;
   }
   try {
-    writeFileSync7(
+    writeFileSync9(
       markerPath,
       `${JSON.stringify(
         {
-          command: HOOK_COMMAND4,
+          command: HOOK_COMMAND6,
           description: "yakcc tool-call interception hook for Windsurf",
           sessionEnvVar: "WINDSURF_SESSION_ID",
           telemetryPrefix: "windsurf",
@@ -9314,7 +9890,7 @@ async function hooksWindsurfInstall(argv, logger) {
     logger.log(`yakcc windsurf hook already installed at ${settingsPath} (idempotent).`);
   } else {
     logger.log(`yakcc windsurf hook installed at ${settingsPath}`);
-    logger.log(`hook command: ${HOOK_COMMAND4}`);
+    logger.log(`hook command: ${HOOK_COMMAND6}`);
     logger.log("session env var: WINDSURF_SESSION_ID");
     logger.log(`marker: ${markerPath}`);
     logger.log(
@@ -9326,43 +9902,43 @@ async function hooksWindsurfInstall(argv, logger) {
 
 // src/commands/init.ts
 init_dist2();
-import { existsSync as existsSync11, mkdirSync as mkdirSync11, readFileSync as readFileSync11, writeFileSync as writeFileSync10 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync13, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "fs";
+import { join as join22 } from "path";
 import { parseArgs as parseArgs12 } from "util";
 
 // src/lib/ide-detect.ts
-import { existsSync as existsSync7 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join14 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join20 } from "path";
 function buildCandidatePaths(home) {
   const platform = process.platform;
   const cursorCandidates = (() => {
     if (platform === "darwin") {
-      return [join14(home, "Library", "Application Support", "Cursor")];
+      return [join20(home, "Library", "Application Support", "Cursor")];
     }
     if (platform === "win32") {
       const appdata = process.env.APPDATA;
       if (appdata !== void 0) {
-        return [join14(appdata, "Cursor")];
+        return [join20(appdata, "Cursor")];
       }
-      return [join14(home, "AppData", "Roaming", "Cursor")];
+      return [join20(home, "AppData", "Roaming", "Cursor")];
     }
-    return [join14(home, ".config", "Cursor")];
+    return [join20(home, ".config", "Cursor")];
   })();
   const clineCandidates = [
-    join14(home, ".config", "cline"),
+    join20(home, ".config", "cline"),
     // VS Code extension dir marker — check the containing directory prefix since
     // the actual extension dir includes a version suffix.
-    join14(home, ".vscode", "extensions", "saoudrizwan.claude-dev")
+    join20(home, ".vscode", "extensions", "saoudrizwan.claude-dev")
   ];
   const continueCandidates = [
-    join14(home, ".continue"),
-    join14(home, ".vscode", "extensions", "continue.continue")
+    join20(home, ".continue"),
+    join20(home, ".vscode", "extensions", "continue.continue")
   ];
-  const windsurfCandidates = [join14(home, ".windsurf")];
-  const aiderCandidates = [join14(home, ".aider")];
+  const windsurfCandidates = [join20(home, ".windsurf")];
+  const aiderCandidates = [join20(home, ".aider")];
   return {
-    "claude-code": [join14(home, ".claude")],
+    "claude-code": [join20(home, ".claude")],
     cursor: cursorCandidates,
     cline: clineCandidates,
     continue: continueCandidates,
@@ -9371,12 +9947,12 @@ function buildCandidatePaths(home) {
   };
 }
 function detectInstalledIdes(overrideHome) {
-  const home = overrideHome ?? homedir2();
+  const home = overrideHome ?? homedir5();
   const candidates = buildCandidatePaths(home);
   const detected = [];
   for (const [name, paths] of Object.entries(candidates)) {
     for (const configDir of paths) {
-      if (existsSync7(configDir)) {
+      if (existsSync11(configDir)) {
         detected.push({ name, configDir, installed: true });
         break;
       }
@@ -9393,185 +9969,17 @@ var KNOWN_IDE_NAMES = [
   "aider"
 ];
 
-// src/commands/hooks-cline-install.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync9, readFileSync as readFileSync9, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join15 } from "path";
-import { parseArgs as parseArgs10 } from "util";
-var CLINE_HOOK_MARKER_FILENAME = "yakcc-cline-hook.json";
-var YAKCC_CLINE_MARKER = "yakcc-hook-v1-cline";
-var HOOK_COMMAND5 = "yakcc hook-intercept";
-function readMarker2(markerPath) {
-  if (!existsSync8(markerPath)) return null;
-  try {
-    return JSON.parse(readFileSync9(markerPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function isYakccInstalled4(markerPath) {
-  const marker = readMarker2(markerPath);
-  return marker !== null && marker._yakcc === YAKCC_CLINE_MARKER;
-}
-async function hooksClineInstall(argv, logger, overrideClineDir) {
-  let parsed;
-  try {
-    parsed = parseArgs10({
-      args: [...argv],
-      options: {
-        target: { type: "string", short: "t" },
-        uninstall: { type: "boolean" }
-      },
-      allowPositionals: false,
-      strict: true
-    });
-  } catch (err) {
-    logger.error(`error: ${err.message}`);
-    return 1;
-  }
-  const clineDir = overrideClineDir ?? join15(homedir3(), ".config", "cline");
-  const markerPath = join15(clineDir, CLINE_HOOK_MARKER_FILENAME);
-  try {
-    mkdirSync9(clineDir, { recursive: true });
-  } catch (err) {
-    logger.error(`error: cannot create ${clineDir}: ${String(err)}`);
-    return 1;
-  }
-  if (parsed.values.uninstall) {
-    if (!isYakccInstalled4(markerPath)) {
-      logger.log("yakcc cline hook not installed \u2014 nothing to uninstall.");
-      return 0;
-    }
-    try {
-      rmSync3(markerPath);
-    } catch (err) {
-      logger.error(`error: cannot remove ${markerPath}: ${String(err)}`);
-      return 1;
-    }
-    logger.log(`yakcc cline hook marker removed: ${markerPath}`);
-    return 0;
-  }
-  if (isYakccInstalled4(markerPath)) {
-    logger.log(`yakcc cline hook already installed at ${markerPath} (idempotent).`);
-    return 0;
-  }
-  const marker = {
-    command: HOOK_COMMAND5,
-    description: "yakcc tool-call interception hook for Cline",
-    sessionEnvVar: "CLINE_SESSION_ID",
-    telemetryPrefix: "cline",
-    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    _yakcc: YAKCC_CLINE_MARKER,
-    note: "Cline (saoudrizwan.claude-dev) does not yet expose synchronous tool-call interception via a stable Node.js API. This marker documents the intended wiring (DEC-CLI-HOOKS-CLINE-INSTALL-001). When the Cline extension API stabilises, hook activation requires no reinstall."
-  };
-  try {
-    writeFileSync8(markerPath, `${JSON.stringify(marker, null, 2)}
-`, "utf-8");
-  } catch (err) {
-    logger.error(`error: cannot write marker ${markerPath}: ${String(err)}`);
-    return 1;
-  }
-  logger.log(`yakcc cline hook marker installed: ${markerPath}`);
-  logger.log("note: Cline tool-call interception API not yet stable \u2014 see marker for details.");
-  return 0;
-}
-
-// src/commands/hooks-continue-install.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync10, readFileSync as readFileSync10, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join16 } from "path";
-import { parseArgs as parseArgs11 } from "util";
-var CONTINUE_HOOK_MARKER_FILENAME = "yakcc-continue-hook.json";
-var YAKCC_CONTINUE_MARKER = "yakcc-hook-v1-continue";
-var HOOK_COMMAND6 = "yakcc hook-intercept";
-function readMarker3(markerPath) {
-  if (!existsSync9(markerPath)) return null;
-  try {
-    return JSON.parse(readFileSync10(markerPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function isYakccInstalled5(markerPath) {
-  const marker = readMarker3(markerPath);
-  return marker !== null && marker._yakcc === YAKCC_CONTINUE_MARKER;
-}
-async function hooksContinueInstall(argv, logger, overrideContinueDir) {
-  let parsed;
-  try {
-    parsed = parseArgs11({
-      args: [...argv],
-      options: {
-        target: { type: "string", short: "t" },
-        uninstall: { type: "boolean" }
-      },
-      allowPositionals: false,
-      strict: true
-    });
-  } catch (err) {
-    logger.error(`error: ${err.message}`);
-    return 1;
-  }
-  const continueDir = overrideContinueDir ?? join16(homedir4(), ".continue");
-  const markerPath = join16(continueDir, CONTINUE_HOOK_MARKER_FILENAME);
-  try {
-    mkdirSync10(continueDir, { recursive: true });
-  } catch (err) {
-    logger.error(`error: cannot create ${continueDir}: ${String(err)}`);
-    return 1;
-  }
-  if (parsed.values.uninstall) {
-    if (!isYakccInstalled5(markerPath)) {
-      logger.log("yakcc continue hook not installed \u2014 nothing to uninstall.");
-      return 0;
-    }
-    try {
-      rmSync4(markerPath);
-    } catch (err) {
-      logger.error(`error: cannot remove ${markerPath}: ${String(err)}`);
-      return 1;
-    }
-    logger.log(`yakcc continue hook marker removed: ${markerPath}`);
-    return 0;
-  }
-  if (isYakccInstalled5(markerPath)) {
-    logger.log(`yakcc continue hook already installed at ${markerPath} (idempotent).`);
-    return 0;
-  }
-  const marker = {
-    command: HOOK_COMMAND6,
-    description: "yakcc tool-call interception hook for Continue.dev",
-    sessionEnvVar: "CONTINUE_SESSION_ID",
-    telemetryPrefix: "continue",
-    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    _yakcc: YAKCC_CONTINUE_MARKER,
-    note: "Continue.dev (continue.continue) does not yet expose synchronous tool-call interception via a stable Node.js API. This marker documents the intended wiring (DEC-CLI-HOOKS-CONTINUE-INSTALL-001). When the Continue.dev API stabilises, hook activation requires no reinstall."
-  };
-  try {
-    writeFileSync9(markerPath, `${JSON.stringify(marker, null, 2)}
-`, "utf-8");
-  } catch (err) {
-    logger.error(`error: cannot write marker ${markerPath}: ${String(err)}`);
-    return 1;
-  }
-  logger.log(`yakcc continue hook marker installed: ${markerPath}`);
-  logger.log(
-    "note: Continue.dev tool-call interception API not yet stable \u2014 see marker for details."
-  );
-  return 0;
-}
-
 // src/commands/seed-yakcc.ts
 init_dist2();
-import { existsSync as existsSync10 } from "fs";
-import { dirname as dirname6, join as join17 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { existsSync as existsSync12 } from "fs";
+import { dirname as dirname7, join as join21 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 function findBootstrapSqlite() {
-  let dir = dirname6(fileURLToPath2(import.meta.url));
+  let dir = dirname7(fileURLToPath3(import.meta.url));
   for (let i = 0; i < 30; i++) {
-    const candidate = join17(dir, "bootstrap", "yakcc.registry.sqlite");
-    if (existsSync10(candidate)) return candidate;
-    const parent = dirname6(dir);
+    const candidate = join21(dir, "bootstrap", "yakcc.registry.sqlite");
+    if (existsSync12(candidate)) return candidate;
+    const parent = dirname7(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -9660,16 +10068,16 @@ var YAKCC_SUBDIRS = ["registry", "telemetry", "config"];
 var DEFAULT_REGISTRY_SUBPATH = ".yakcc/registry.sqlite";
 var RC_FILENAME = ".yakccrc.json";
 function readRc(targetDir) {
-  const rcPath = join18(targetDir, RC_FILENAME);
-  if (!existsSync11(rcPath)) return null;
+  const rcPath = join22(targetDir, RC_FILENAME);
+  if (!existsSync13(rcPath)) return null;
   try {
-    return JSON.parse(readFileSync11(rcPath, "utf-8"));
+    return JSON.parse(readFileSync13(rcPath, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeRc(targetDir, rc) {
-  writeFileSync10(join18(targetDir, RC_FILENAME), `${JSON.stringify(rc, null, 2)}
+  writeFileSync10(join22(targetDir, RC_FILENAME), `${JSON.stringify(rc, null, 2)}
 `, "utf-8");
 }
 function validatePeerUrl(url) {
@@ -9694,8 +10102,8 @@ function parseIdeList(raw) {
   return { ok: parts };
 }
 async function installHookForIde(ide, targetDir, logger, overrideHome) {
-  const { homedir: homedir6 } = await import("os");
-  const home = overrideHome ?? homedir6();
+  const { homedir: homedir7 } = await import("os");
+  const home = overrideHome ?? homedir7();
   switch (ide) {
     case "claude-code": {
       const code = await hooksClaudeCodeInstall(["--target", targetDir], logger);
@@ -9708,15 +10116,15 @@ async function installHookForIde(ide, targetDir, logger, overrideHome) {
       break;
     }
     case "cline": {
-      const { join: join20 } = await import("path");
-      const clineDir = join20(home, ".config", "cline");
+      const { join: join24 } = await import("path");
+      const clineDir = join24(home, ".config", "cline");
       const code = await hooksClineInstall([], logger, clineDir);
       if (code !== 0) throw new Error(`cline hook install failed (exit ${code})`);
       break;
     }
     case "continue": {
-      const { join: join20 } = await import("path");
-      const continueDir = join20(home, ".continue");
+      const { join: join24 } = await import("path");
+      const continueDir = join24(home, ".continue");
       const code = await hooksContinueInstall([], logger, continueDir);
       if (code !== 0) throw new Error(`continue hook install failed (exit ${code})`);
       break;
@@ -9727,8 +10135,8 @@ async function installHookForIde(ide, targetDir, logger, overrideHome) {
       break;
     }
     case "aider": {
-      const { join: join20 } = await import("path");
-      const aiderDir = join20(home, ".aider");
+      const { join: join24 } = await import("path");
+      const aiderDir = join24(home, ".aider");
       const code = await hooksAiderInstall([], logger, aiderDir);
       if (code !== 0) throw new Error(`aider hook install failed (exit ${code})`);
       break;
@@ -9790,12 +10198,12 @@ async function init(argv, logger, opts) {
     }
     explicitIdes = parseResult.ok;
   }
-  const yakccDir = join18(targetDir, YAKCC_DIR);
-  const yakccDirExists = existsSync11(yakccDir);
+  const yakccDir = join22(targetDir, YAKCC_DIR);
+  const yakccDirExists = existsSync13(yakccDir);
   try {
-    mkdirSync11(yakccDir, { recursive: true });
+    mkdirSync13(yakccDir, { recursive: true });
     for (const sub of YAKCC_SUBDIRS) {
-      mkdirSync11(join18(yakccDir, sub), { recursive: true });
+      mkdirSync13(join22(yakccDir, sub), { recursive: true });
     }
   } catch (err) {
     logger.error(`error: cannot create ${yakccDir}: ${String(err)}`);
@@ -9806,7 +10214,7 @@ async function init(argv, logger, opts) {
   } else {
     logger.log("  .yakcc/  created");
   }
-  const registryPath = join18(targetDir, DEFAULT_REGISTRY_SUBPATH);
+  const registryPath = join22(targetDir, DEFAULT_REGISTRY_SUBPATH);
   const registryCode = await registryInit(["--path", registryPath], logger);
   if (registryCode !== 0) {
     return registryCode;
@@ -9891,7 +10299,7 @@ async function init(argv, logger, opts) {
   try {
     writeRc(targetDir, rc);
   } catch (err) {
-    logger.error(`error: cannot write ${join18(targetDir, RC_FILENAME)}: ${String(err)}`);
+    logger.error(`error: cannot write ${join22(targetDir, RC_FILENAME)}: ${String(err)}`);
     return 1;
   }
   logger.log(`  ${RC_FILENAME}  written`);
@@ -9910,7 +10318,7 @@ async function init(argv, logger, opts) {
 // src/commands/propose.ts
 init_dist();
 init_dist2();
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 import { parseArgs as parseArgs13 } from "util";
 async function propose(argv, logger) {
   const { values, positionals } = parseArgs13({
@@ -9937,7 +10345,7 @@ async function propose(argv, logger) {
   const registryPath = values.registry ?? DEFAULT_REGISTRY_PATH3;
   let specJson;
   try {
-    specJson = readFileSync12(specFilePath, "utf-8");
+    specJson = readFileSync14(specFilePath, "utf-8");
   } catch (err) {
     logger.error(`error: cannot read spec file ${specFilePath}: ${String(err)}`);
     return 1;
@@ -9978,7 +10386,7 @@ async function propose(argv, logger) {
 
 // src/commands/query.ts
 init_dist2();
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync15 } from "fs";
 import { parseArgs as parseArgs14 } from "util";
 function truncate(s, max) {
   return s.length <= max ? s : `${s.slice(0, max - 3)}...`;
@@ -10008,7 +10416,7 @@ async function query(argv, logger, opts) {
   if (cardFilePath !== void 0) {
     let cardJson;
     try {
-      cardJson = readFileSync13(cardFilePath, "utf-8");
+      cardJson = readFileSync15(cardFilePath, "utf-8");
     } catch (err) {
       logger.error(`error: cannot read card file ${cardFilePath}: ${String(err)}`);
       return 1;
@@ -10086,9 +10494,9 @@ async function query(argv, logger, opts) {
 }
 
 // src/commands/registry-export.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync12 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync14 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { dirname as dirname7, resolve as resolve3 } from "path";
+import { dirname as dirname8, resolve as resolve4 } from "path";
 import { parseArgs as parseArgs15 } from "util";
 var _registryModuleUrl = new URL("../../../registry/src/index.ts", import.meta.url).href;
 var _req = createRequire2(_registryModuleUrl);
@@ -10106,13 +10514,13 @@ async function registryExport(argv, logger) {
     logger.error("error: --to <path> is required for 'registry export'");
     return 1;
   }
-  const sourcePath = resolve3(values.from);
-  const outputPath = resolve3(values.to);
-  if (!existsSync12(sourcePath)) {
+  const sourcePath = resolve4(values.from);
+  const outputPath = resolve4(values.to);
+  if (!existsSync14(sourcePath)) {
     logger.error(`error: source registry not found at ${sourcePath}`);
     return 1;
   }
-  mkdirSync12(dirname7(outputPath), { recursive: true });
+  mkdirSync14(dirname8(outputPath), { recursive: true });
   const escapedOutputPath = outputPath.replace(/'/g, "''");
   let Database2;
   try {
@@ -10153,8 +10561,8 @@ async function registryExport(argv, logger) {
 
 // src/commands/registry-rebuild.ts
 init_dist2();
-import { mkdirSync as mkdirSync13 } from "fs";
-import { dirname as dirname8 } from "path";
+import { mkdirSync as mkdirSync15 } from "fs";
+import { dirname as dirname9 } from "path";
 import { parseArgs as parseArgs16 } from "util";
 async function registryRebuild(argv, logger, opts) {
   const { values } = parseArgs16({
@@ -10166,8 +10574,8 @@ async function registryRebuild(argv, logger, opts) {
     strict: true
   });
   const registryPath = values.path ?? DEFAULT_REGISTRY_PATH3;
-  const parent = dirname8(registryPath);
-  mkdirSync13(parent, { recursive: true });
+  const parent = dirname9(registryPath);
+  mkdirSync15(parent, { recursive: true });
   let embeddingProvider = opts?.embeddings;
   if (embeddingProvider === void 0) {
     const { createLocalEmbeddingProvider: createLocalEmbeddingProvider2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
@@ -10207,7 +10615,7 @@ async function registryRebuild(argv, logger, opts) {
 // src/commands/search.ts
 init_dist();
 init_dist2();
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 import { parseArgs as parseArgs17 } from "util";
 var FREE_TEXT_SPEC_DEFAULTS = {
   inputs: [],
@@ -10259,7 +10667,7 @@ async function search(argv, logger, opts) {
   if (looksLikePath) {
     let specJson;
     try {
-      specJson = readFileSync14(query2, "utf-8");
+      specJson = readFileSync16(query2, "utf-8");
     } catch (err) {
       logger.error(`error: cannot read spec file ${query2}: ${String(err)}`);
       return 1;
@@ -10368,7 +10776,7 @@ async function seed(argv, logger, opts) {
 
 // src/commands/shave.ts
 init_dist2();
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 import { parseArgs as parseArgs19 } from "util";
 var VALID_FOREIGN_POLICIES = ["allow", "reject", "tag"];
 var SHAVE_PARSE_OPTIONS = {
@@ -10419,7 +10827,7 @@ async function shave2(argv, logger) {
   const offline = parsed.values.offline === true;
   let registry;
   try {
-    registry = await openRegistry(resolve4(registryPath));
+    registry = await openRegistry(resolve5(registryPath));
   } catch (err) {
     logger.error(`error: failed to open registry at ${registryPath}: ${err.message}`);
     return 1;
@@ -10433,7 +10841,7 @@ async function shave2(argv, logger) {
     findByCanonicalAstHash: registry.findByCanonicalAstHash?.bind(registry)
   };
   try {
-    const result = await shave(resolve4(sourcePath), shaveRegistry, { offline, foreignPolicy });
+    const result = await shave(resolve5(sourcePath), shaveRegistry, { offline, foreignPolicy });
     logger.log(`Shaved ${result.sourcePath}:`);
     logger.log(`  atoms: ${result.atoms.length}`);
     logger.log(`  intentCards: ${result.intentCards.length}`);
@@ -10467,17 +10875,17 @@ async function shave2(argv, logger) {
 }
 
 // src/commands/uninstall.ts
-import { existsSync as existsSync13, readFileSync as readFileSync15, rmSync as rmSync5, writeFileSync as writeFileSync11 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join19, resolve as resolve5 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync17, rmSync as rmSync5, writeFileSync as writeFileSync11 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join23, resolve as resolve6 } from "path";
 import { parseArgs as parseArgs20 } from "util";
 var YAKCC_DIR2 = ".yakcc";
 var RC_FILENAME2 = ".yakccrc.json";
 function readRc2(targetDir) {
-  const rcPath = join19(targetDir, RC_FILENAME2);
-  if (!existsSync13(rcPath)) return null;
+  const rcPath = join23(targetDir, RC_FILENAME2);
+  if (!existsSync15(rcPath)) return null;
   try {
-    return JSON.parse(readFileSync15(rcPath, "utf-8"));
+    return JSON.parse(readFileSync17(rcPath, "utf-8"));
   } catch {
     return null;
   }
@@ -10493,20 +10901,20 @@ function parseIdeList2(raw) {
   return { ok: parts };
 }
 async function uninstallHookForIde(ide, targetDir, logger, overrideHome) {
-  const home = overrideHome ?? homedir5();
+  const home = overrideHome ?? homedir6();
   switch (ide) {
     case "claude-code":
       return hooksClaudeCodeInstall(["--target", targetDir, "--uninstall"], logger);
     case "cursor":
       return hooksCursorInstall(["--target", targetDir, "--uninstall"], logger);
     case "cline":
-      return hooksClineInstall(["--uninstall"], logger, join19(home, ".config", "cline"));
+      return hooksClineInstall(["--uninstall"], logger, join23(home, ".config", "cline"));
     case "continue":
-      return hooksContinueInstall(["--uninstall"], logger, join19(home, ".continue"));
+      return hooksContinueInstall(["--uninstall"], logger, join23(home, ".continue"));
     case "windsurf":
       return hooksWindsurfInstall(["--target", targetDir, "--uninstall"], logger);
     case "aider":
-      return hooksAiderInstall(["--uninstall"], logger, join19(home, ".aider"));
+      return hooksAiderInstall(["--uninstall"], logger, join23(home, ".aider"));
   }
 }
 async function uninstall(argv, logger, opts) {
@@ -10582,7 +10990,7 @@ async function uninstall(argv, logger, opts) {
       const updated = { ...rc, installedHooks: updatedHooks };
       try {
         writeFileSync11(
-          join19(targetDir, RC_FILENAME2),
+          join23(targetDir, RC_FILENAME2),
           `${JSON.stringify(updated, null, 2)}
 `,
           "utf-8"
@@ -10594,22 +11002,22 @@ async function uninstall(argv, logger, opts) {
   }
   if (doPurge) {
     try {
-      rmSync5(join19(targetDir, YAKCC_DIR2), { recursive: true, force: true });
+      rmSync5(join23(targetDir, YAKCC_DIR2), { recursive: true, force: true });
     } catch (err) {
       logger.error(`warning: cannot remove ${YAKCC_DIR2}: ${String(err)}`);
     }
     try {
-      rmSync5(join19(targetDir, RC_FILENAME2), { force: true });
+      rmSync5(join23(targetDir, RC_FILENAME2), { force: true });
     } catch (err) {
       logger.error(`warning: cannot remove ${RC_FILENAME2}: ${String(err)}`);
     }
   }
-  const absTargetDir = resolve5(targetDir);
+  const absTargetDir = resolve6(targetDir);
   const removedLine = removedIdes.length > 0 ? `Removed from: ${removedIdes.join(", ")}.` : "No hooks removed (nothing was installed).";
   if (doPurge) {
     logger.log(`${removedLine} Purged .yakcc/ and ${RC_FILENAME2} at ${absTargetDir}.`);
   } else {
-    logger.log(`${removedLine} Registry preserved at ${join19(absTargetDir, YAKCC_DIR2)}.`);
+    logger.log(`${removedLine} Registry preserved at ${join23(absTargetDir, YAKCC_DIR2)}.`);
   }
   return 0;
 }
@@ -10677,6 +11085,13 @@ COMMANDS
   hooks cursor install                Wire yakcc tool-call interception for Cursor
                 [--target <dir>]      Target project directory (default: .)
                 [--uninstall]         Remove the yakcc cursor hook entry
+  hooks cline install                 Wire yakcc tool-call interception for Cline
+                [--target <dir>]      Target project directory (default: .)
+                [--uninstall]         Remove the yakcc cline hook entry
+  hooks continue install              Wire yakcc tool-call interception for Continue.dev
+                [--target <dir>]      Target project directory (default: .)
+                [--uninstall]         Remove the yakcc continue hook entry
+  hook-intercept                      (internal -- invoked by IDE hook configs via PreToolUse)
   federation serve --registry <p>     Start a read-only HTTP registry server
                 [--port <n>] [--host <h>]
   federation mirror --remote <url>    Mirror all blocks from a remote registry peer
@@ -10795,11 +11210,35 @@ async function runCli(argv, logger = CONSOLE_LOGGER, opts) {
         );
         return 1;
       }
+      if (subcommand === "cline") {
+        const [hooksSub, ...hooksRest] = rest;
+        if (hooksSub === "install") {
+          return hooksClineInstall(hooksRest, logger);
+        }
+        logger.error(
+          `error: unknown hooks cline subcommand: ${hooksSub ?? "(none)"}. Did you mean 'hooks cline install'?`
+        );
+        return 1;
+      }
+      if (subcommand === "continue") {
+        const [hooksSub, ...hooksRest] = rest;
+        if (hooksSub === "install") {
+          return hooksContinueInstall(hooksRest, logger);
+        }
+        logger.error(
+          `error: unknown hooks continue subcommand: ${hooksSub ?? "(none)"}. Did you mean 'hooks continue install'?`
+        );
+        return 1;
+      }
       logger.error(
-        `error: unknown hooks subcommand: ${subcommand ?? "(none)"}. Did you mean 'hooks claude-code install', 'hooks cursor install', 'hooks windsurf install', or 'hooks aider install'?`
+        `error: unknown hooks subcommand: ${subcommand ?? "(none)"}. Did you mean 'hooks claude-code install', 'hooks cursor install', 'hooks windsurf install', 'hooks aider install', 'hooks cline install', or 'hooks continue install'?`
       );
       return 1;
     }
+    case "hook-intercept": {
+      const hookInterceptArgv = subcommand !== void 0 ? [subcommand, ...rest] : rest;
+      return hookIntercept(hookInterceptArgv, logger);
+    }
     case void 0:
     case "--help":
     case "-h": {