tianshu-harness 3.23.0

package/dist/chunk-ZZAWNALS.js

@@ -0,0 +1,350 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  buildPinnedLookup,
+  resolveAndAssertPublic
+} from "./chunk-5JRZPLI6.js";
+import {
+  resolveProxyForUrl
+} from "./chunk-2HDP7RMR.js";
+import {
+  require_undici
+} from "./chunk-O5VZQKCB.js";
+import {
+  buildAuthorizeUrl,
+  generatePKCE,
+  shouldRefresh
+} from "./chunk-EPKTIOED.js";
+import {
+  TokenStore
+} from "./chunk-2VYRLULP.js";
+import {
+  init_paths,
+  rivetHome
+} from "./chunk-BCQXEZPJ.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/mcp/oauth/connector.ts
+init_esm_shims();
+var import_undici = __toESM(require_undici(), 1);
+import { randomBytes } from "crypto";
+import dns from "dns/promises";
+import { join } from "path";
+import { createServer } from "http";
+init_paths();
+var REDIRECT_PORT = parseInt(process.env.RIVET_OAUTH_PORT || "1456", 10);
+var CALLBACK_PATH = "/auth/callback";
+var CALLBACK_TIMEOUT_MS = 5 * 6e4;
+var OAUTH_TIMEOUT_MS = 3e4;
+var MAX_TOKEN_RESPONSE_BYTES = 64 * 1024;
+function mcpOAuthDir() {
+  return join(rivetHome(), "mcp-oauth");
+}
+function tokenStore(serverId) {
+  return new TokenStore(mcpOAuthDir(), serverId);
+}
+async function startMcpOAuth(serverId, provider, clientId, extraScopes) {
+  const pkce = await generatePKCE();
+  const state = randomBytes(16).toString("hex");
+  const redirectUri = `http://localhost:${REDIRECT_PORT}${CALLBACK_PATH}`;
+  const scopes = [...provider.defaultScopes, ...extraScopes ?? []];
+  const authUrl = buildAuthorizeUrl({
+    clientId,
+    codeChallenge: pkce.challenge,
+    redirectUri,
+    state,
+    authorizeBase: provider.authorizeUrl
+  });
+  const url = new URL(authUrl);
+  url.searchParams.set("scope", scopes.join(" "));
+  const code = await serveCallback(REDIRECT_PORT, state, url.toString());
+  const token = await exchange(code, pkce.verifier, redirectUri, provider, clientId);
+  const mcpToken = {
+    ...token,
+    provider: provider.id,
+    scopes
+  };
+  tokenStore(serverId).save({
+    ...token,
+    _provider: provider.id,
+    _scopes: scopes
+  });
+  return mcpToken;
+}
+async function getMcpAccessToken(serverId, provider, clientId) {
+  const store = tokenStore(serverId);
+  let token = store.load();
+  if (!token) throw new Error(`No OAuth token for MCP server "${serverId}" \u2014 run /mcp auth ${serverId}`);
+  if (shouldRefresh(token)) {
+    token = await refreshMcpToken(token, provider, clientId);
+    store.save(token);
+  }
+  return token.accessToken;
+}
+function hasMcpOAuthToken(serverId) {
+  const token = tokenStore(serverId).load();
+  return token !== null && token.expiresAt > Date.now();
+}
+function revokeMcpOAuth(serverId) {
+  tokenStore(serverId).clear();
+}
+function loadMcpOAuthToken(serverId) {
+  const data = tokenStore(serverId).load();
+  if (!data) return null;
+  if (data.expiresAt <= Date.now()) return null;
+  return {
+    accessToken: data.accessToken,
+    refreshToken: data.refreshToken,
+    expiresAt: data.expiresAt,
+    provider: data._provider ?? "",
+    scopes: data._scopes ?? []
+  };
+}
+var sharedServer = null;
+var sharedServerPort = null;
+var serverStartPromise = null;
+var pendingCallbacks = /* @__PURE__ */ new Map();
+async function getOrStartSharedServer(port) {
+  if (sharedServer && sharedServerPort === port) return;
+  if (serverStartPromise) {
+    await serverStartPromise;
+    if (sharedServerPort !== port) return getOrStartSharedServer(port);
+    return;
+  }
+  serverStartPromise = new Promise((resolve, reject) => {
+    const server = createServer((req, res) => {
+      handleCallbackRequest(req, res);
+    });
+    server.once("error", (err) => {
+      const wasStarting = serverStartPromise !== null;
+      const allPending = Array.from(pendingCallbacks.values());
+      closeSharedServer().catch(() => {
+      });
+      if (wasStarting) {
+        reject(err);
+      } else {
+        for (const pending of allPending) pending.reject(err);
+      }
+    });
+    server.listen(port, "127.0.0.1", () => {
+      sharedServer = server;
+      sharedServerPort = port;
+      resolve();
+    });
+  });
+  try {
+    await serverStartPromise;
+  } finally {
+    if (serverStartPromise) serverStartPromise = null;
+  }
+}
+async function closeSharedServer() {
+  const server = sharedServer;
+  sharedServer = null;
+  sharedServerPort = null;
+  serverStartPromise = null;
+  for (const pending of pendingCallbacks.values()) clearTimeout(pending.timeout);
+  pendingCallbacks.clear();
+  if (server) {
+    await new Promise((resolve) => server.close(() => resolve()));
+  }
+}
+function handleCallbackRequest(req, res) {
+  const port = sharedServerPort ?? REDIRECT_PORT;
+  const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+  if (url.pathname !== CALLBACK_PATH) {
+    res.writeHead(404, { "Content-Type": "text/html" });
+    res.end("<h1>Not found</h1>");
+    return;
+  }
+  const state = url.searchParams.get("state");
+  const code = url.searchParams.get("code");
+  const pending = state ? pendingCallbacks.get(state) : void 0;
+  if (!pending) {
+    res.writeHead(400, { "Content-Type": "text/html" });
+    res.end("<h1>Unknown or expired authorization session</h1>");
+    return;
+  }
+  if (!code) {
+    const providerError = sanitizeProviderText(url.searchParams.get("error") ?? "unknown");
+    res.writeHead(400, { "Content-Type": "text/html" });
+    res.end(`<h1>Authorization failed: ${escapeHtml(providerError)}</h1>`);
+    pending.reject(new Error(`OAuth error: ${providerError}`));
+    return;
+  }
+  res.writeHead(200, { "Content-Type": "text/html" });
+  res.end("<h1>MCP connected \u2014 you can close this tab</h1>");
+  pending.resolve(code);
+}
+function escapeHtml(s) {
+  const map = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+  return s.replace(/[&<>"']/g, (c) => map[c] ?? c);
+}
+function sanitizeProviderText(raw, maxLength = 200) {
+  return raw.replace(/[\u0000-\u001f\u007f-\u009f]/g, "").slice(0, maxLength);
+}
+async function serveCallback(port, expectedState, authUrl, timeoutMs = CALLBACK_TIMEOUT_MS) {
+  await getOrStartSharedServer(port);
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      cleanup();
+      reject(new Error(`OAuth callback timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timeout);
+      pendingCallbacks.delete(expectedState);
+      if (pendingCallbacks.size === 0) {
+        closeSharedServer().catch(() => {
+        });
+      }
+    };
+    pendingCallbacks.set(expectedState, {
+      resolve: (code) => {
+        cleanup();
+        resolve(code);
+      },
+      reject: (err) => {
+        cleanup();
+        reject(err);
+      },
+      timeout
+    });
+    process.stderr.write(`Open this URL to connect MCP:
+${authUrl}
+`);
+  });
+}
+async function postTokenRequest(endpoint, form) {
+  const url = new URL(endpoint);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`Unsupported OAuth token endpoint protocol: ${url.protocol}`);
+  }
+  const signal = AbortSignal.timeout(OAUTH_TIMEOUT_MS);
+  let abortLookup = () => {
+  };
+  const deadline = new Promise((_resolve, reject) => {
+    abortLookup = () => reject(signal.reason);
+    signal.addEventListener("abort", abortLookup, { once: true });
+    if (signal.aborted) abortLookup();
+  });
+  const resolved = await Promise.race([
+    resolveAndAssertPublic(url.hostname, dns.lookup),
+    deadline
+  ]).finally(() => signal.removeEventListener("abort", abortLookup));
+  signal.throwIfAborted();
+  const proxyUrl = resolveProxyForUrl(url.href);
+  const dispatcher = proxyUrl ? new import_undici.default.ProxyAgent({ uri: proxyUrl }) : new import_undici.default.Agent({ connect: { lookup: buildPinnedLookup(resolved.address, resolved.family) } });
+  try {
+    const response = await import_undici.default.fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json" },
+      body: new URLSearchParams(form).toString(),
+      redirect: "error",
+      dispatcher,
+      signal
+    });
+    return { ok: response.ok, status: response.status, text: await readBodyCapped(response, MAX_TOKEN_RESPONSE_BYTES) };
+  } finally {
+    await dispatcher.destroy().catch(() => {
+    });
+  }
+}
+async function readBodyCapped(response, maxBytes) {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > maxBytes) {
+    const declaredOversize = `OAuth token response declares ${declared} bytes, over the ${maxBytes}-byte limit`;
+    if (response.body) await response.body.cancel(declaredOversize).catch(() => {
+    });
+    throw new Error(declaredOversize);
+  }
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel(`OAuth token response exceeds ${maxBytes} bytes`).catch(() => {
+        });
+        throw new Error(`OAuth token response exceeds ${maxBytes} bytes`);
+      }
+      chunks.push(value);
+    }
+  } catch (err) {
+    await reader.cancel().catch(() => {
+    });
+    throw err;
+  }
+  const merged = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(merged);
+}
+async function exchange(code, codeVerifier, redirectUri, provider, clientId) {
+  const resp = await postTokenRequest(provider.tokenEndpoint, {
+    grant_type: "authorization_code",
+    client_id: clientId,
+    code,
+    code_verifier: codeVerifier,
+    redirect_uri: redirectUri
+  });
+  const text = resp.text;
+  let data;
+  if (text.startsWith("{")) {
+    data = JSON.parse(text);
+  } else {
+    const params = new URLSearchParams(text);
+    data = Object.fromEntries(params.entries());
+  }
+  if (!resp.ok || typeof data.error === "string") {
+    const detail = typeof data.error === "string" ? data.error : text;
+    throw new Error(`Token exchange failed (${resp.status}): ${sanitizeProviderText(detail)}`);
+  }
+  const expiresIn = typeof data.expires_in === "number" ? data.expires_in : typeof data.expires_in === "string" ? Number.parseInt(data.expires_in, 10) : 3600;
+  return {
+    accessToken: data.access_token ?? data.accessToken,
+    refreshToken: typeof data.refresh_token === "string" ? data.refresh_token : void 0,
+    expiresAt: Date.now() + (Number.isFinite(expiresIn) ? expiresIn : 3600) * 1e3
+  };
+}
+async function refreshMcpToken(token, provider, clientId) {
+  if (!token.refreshToken) throw new Error("No refresh token \u2014 re-authenticate");
+  const resp = await postTokenRequest(provider.tokenEndpoint, {
+    grant_type: "refresh_token",
+    client_id: clientId,
+    refresh_token: token.refreshToken
+  });
+  const text = resp.text;
+  let data;
+  if (text.startsWith("{")) {
+    data = JSON.parse(text);
+  } else {
+    data = Object.fromEntries(new URLSearchParams(text).entries());
+  }
+  if (!resp.ok) throw new Error(`Token refresh failed (${resp.status})`);
+  const expiresIn = typeof data.expires_in === "number" ? data.expires_in : typeof data.expires_in === "string" ? Number.parseInt(data.expires_in, 10) : 3600;
+  return {
+    accessToken: data.access_token ?? data.accessToken,
+    refreshToken: typeof data.refresh_token === "string" ? data.refresh_token : token.refreshToken,
+    expiresAt: Date.now() + (Number.isFinite(expiresIn) ? expiresIn : 3600) * 1e3
+  };
+}
+
+export {
+  startMcpOAuth,
+  getMcpAccessToken,
+  hasMcpOAuthToken,
+  revokeMcpOAuth,
+  loadMcpOAuthToken,
+  serveCallback
+};

package/dist/cli/entry.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  HELP_TEXT,
+  applyEarlyCliEnv,
+  routeEarlyCli
+} from "../chunk-C6ZVZCPP.js";
+import {
+  formatVersionLine
+} from "../chunk-66JPZSGX.js";
+import {
+  init_paths,
+  rivetHome
+} from "../chunk-BCQXEZPJ.js";
+import {
+  init_esm_shims
+} from "../chunk-5GGOGLSN.js";
+
+// src/cli/entry.ts
+init_esm_shims();
+import { mkdirSync } from "fs";
+import { enableCompileCache } from "module";
+import { join } from "path";
+init_paths();
+function enableCliCompileCache() {
+  if (typeof enableCompileCache !== "function") return;
+  if (process.env.NODE_COMPILE_CACHE) return;
+  try {
+    const dir = join(rivetHome(), "cli", "compile-cache");
+    mkdirSync(dir, { recursive: true });
+    enableCompileCache(dir);
+    return;
+  } catch {
+  }
+  try {
+    enableCompileCache();
+  } catch {
+  }
+}
+enableCliCompileCache();
+var args = process.argv.slice(2);
+if (args.includes("--help") || args.includes("-h")) {
+  process.stdout.write(HELP_TEXT);
+  process.exit(0);
+}
+if (args.includes("--version") || args.includes("-v")) {
+  process.stdout.write(formatVersionLine());
+  process.exit(0);
+}
+await applyEarlyCliEnv(args);
+if (await routeEarlyCli(args)) {
+} else {
+  await import("../main.js");
+}

package/dist/connector-L5QQTR6Y.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  getMcpAccessToken,
+  hasMcpOAuthToken,
+  loadMcpOAuthToken,
+  revokeMcpOAuth,
+  serveCallback,
+  startMcpOAuth
+} from "./chunk-ZZAWNALS.js";
+import "./chunk-5JRZPLI6.js";
+import "./chunk-2HDP7RMR.js";
+import "./chunk-O5VZQKCB.js";
+import "./chunk-EPKTIOED.js";
+import "./chunk-2VYRLULP.js";
+import "./chunk-P5KJURUR.js";
+import "./chunk-BCQXEZPJ.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  getMcpAccessToken,
+  hasMcpOAuthToken,
+  loadMcpOAuthToken,
+  revokeMcpOAuth,
+  serveCallback,
+  startMcpOAuth
+};

package/dist/context-62DC6EC3.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  EMPTY_USAGE,
+  SessionContext
+} from "./chunk-424AP7FM.js";
+import "./chunk-ZGGCEXDC.js";
+import "./chunk-ZMZCZNKU.js";
+import "./chunk-CEZNQVWM.js";
+import "./chunk-RWA23GMM.js";
+import "./chunk-KIOXTQQL.js";
+import "./chunk-35H7GVNR.js";
+import "./chunk-TPI73L57.js";
+import "./chunk-XU2YXCDL.js";
+import "./chunk-ETHFACAB.js";
+import "./chunk-UFMN76QD.js";
+import "./chunk-QARAGUXX.js";
+import "./chunk-ER5JW2QZ.js";
+import "./chunk-CGFZGR7G.js";
+import "./chunk-P5KJURUR.js";
+import "./chunk-WMUWEO2C.js";
+import "./chunk-BKTQAYO2.js";
+import "./chunk-OO3TAHO5.js";
+import "./chunk-7KUCBNLB.js";
+import "./chunk-A5MNH4ER.js";
+import "./chunk-BCQXEZPJ.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  EMPTY_USAGE,
+  SessionContext
+};

package/dist/council-convene-NJWPNBDU.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  DEFAULT_COUNCIL_SEATS,
+  createCouncilConveneTool,
+  setDeprecatedModelNotesForTest
+} from "./chunk-4U2ET7ZY.js";
+import "./chunk-KWVTXT5B.js";
+import "./chunk-R43HJCDX.js";
+import "./chunk-D4PTYFOG.js";
+import "./chunk-AERM3VGP.js";
+import "./chunk-RK3JHWPT.js";
+import "./chunk-NH6VIOAR.js";
+import "./chunk-S4K4L6IM.js";
+import "./chunk-3VGD2FXB.js";
+import "./chunk-UXNLELW6.js";
+import "./chunk-TVHW77C7.js";
+import "./chunk-EHHUASO5.js";
+import "./chunk-LA6IPTGH.js";
+import "./chunk-HBVF6BWO.js";
+import "./chunk-4QJ3Y5JM.js";
+import "./chunk-CGOADM2X.js";
+import "./chunk-ILBCKAV6.js";
+import "./chunk-6HSVXHCZ.js";
+import "./chunk-OHSV42QB.js";
+import "./chunk-ADIVZ2D5.js";
+import "./chunk-Z5Z3JHJY.js";
+import "./chunk-35H7GVNR.js";
+import "./chunk-CI4R6P2B.js";
+import "./chunk-THKDVSEC.js";
+import "./chunk-UFMN76QD.js";
+import "./chunk-ER5JW2QZ.js";
+import "./chunk-CGFZGR7G.js";
+import "./chunk-P5KJURUR.js";
+import "./chunk-WMUWEO2C.js";
+import "./chunk-BKTQAYO2.js";
+import "./chunk-OO3TAHO5.js";
+import "./chunk-7KUCBNLB.js";
+import "./chunk-A5MNH4ER.js";
+import "./chunk-BCQXEZPJ.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  DEFAULT_COUNCIL_SEATS,
+  createCouncilConveneTool,
+  setDeprecatedModelNotesForTest
+};

package/dist/create-agent-config-ODSQWNVC.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  createAgentConfig,
+  createMainAgentConfigInput,
+  resolveCompactProviderName,
+  resolveFallbackModel
+} from "./chunk-4XPFLICE.js";
+import "./chunk-V5YIPMHV.js";
+import "./chunk-ILBCKAV6.js";
+import "./chunk-X2IK5LVR.js";
+import "./chunk-CEZNQVWM.js";
+import "./chunk-O5VZQKCB.js";
+import "./chunk-SEPGEJNK.js";
+import "./chunk-7RDOV3DF.js";
+import "./chunk-6HSVXHCZ.js";
+import "./chunk-RWA23GMM.js";
+import "./chunk-OHSV42QB.js";
+import "./chunk-ADIVZ2D5.js";
+import "./chunk-7FW3I7WC.js";
+import "./chunk-GD4ZNZ7W.js";
+import "./chunk-ZQKXBUB7.js";
+import "./chunk-Z5Z3JHJY.js";
+import "./chunk-KIOXTQQL.js";
+import "./chunk-35H7GVNR.js";
+import "./chunk-JSXWIWWJ.js";
+import "./chunk-TPI73L57.js";
+import "./chunk-GMKAXSYQ.js";
+import "./chunk-EPKTIOED.js";
+import "./chunk-2VYRLULP.js";
+import "./chunk-SUJERP5I.js";
+import "./chunk-CI4R6P2B.js";
+import "./chunk-XU2YXCDL.js";
+import "./chunk-ETHFACAB.js";
+import "./chunk-UFMN76QD.js";
+import "./chunk-EXUE5W2F.js";
+import "./chunk-6S5FPUS7.js";
+import "./chunk-EXXICUIW.js";
+import "./chunk-QARAGUXX.js";
+import "./chunk-ER5JW2QZ.js";
+import "./chunk-CGFZGR7G.js";
+import "./chunk-P5KJURUR.js";
+import "./chunk-WMUWEO2C.js";
+import "./chunk-BKTQAYO2.js";
+import "./chunk-OO3TAHO5.js";
+import "./chunk-7KUCBNLB.js";
+import "./chunk-A5MNH4ER.js";
+import "./chunk-BCQXEZPJ.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  createAgentConfig,
+  createMainAgentConfigInput,
+  resolveCompactProviderName,
+  resolveFallbackModel
+};

package/dist/default-registry-2PU3BTAU.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  createDefaultToolRegistry
+} from "./chunk-BXHV3GSB.js";
+import "./chunk-FW3QKMFX.js";
+import "./chunk-UXXS53EA.js";
+import "./chunk-JCFWOULR.js";
+import "./chunk-2HKD2UFM.js";
+import "./chunk-5JRZPLI6.js";
+import "./chunk-JRF5L6OD.js";
+import "./chunk-EBJTVRQN.js";
+import "./chunk-J4U4AW46.js";
+import "./chunk-2HDP7RMR.js";
+import "./chunk-4J5TZGOE.js";
+import "./chunk-BUIMGNDD.js";
+import "./chunk-ZU7JZCVP.js";
+import "./chunk-JSS75KCG.js";
+import "./chunk-HBVF6BWO.js";
+import "./chunk-ZGGCEXDC.js";
+import "./chunk-ZMZCZNKU.js";
+import "./chunk-Z3QE7TZM.js";
+import "./chunk-J6ESSM47.js";
+import "./chunk-3C3R7JXY.js";
+import "./chunk-ILBCKAV6.js";
+import "./chunk-X2IK5LVR.js";
+import "./chunk-CEZNQVWM.js";
+import "./chunk-O5VZQKCB.js";
+import "./chunk-7RDOV3DF.js";
+import "./chunk-6HSVXHCZ.js";
+import "./chunk-OHSV42QB.js";
+import "./chunk-ADIVZ2D5.js";
+import "./chunk-7FW3I7WC.js";
+import "./chunk-GD4ZNZ7W.js";
+import "./chunk-ZQKXBUB7.js";
+import "./chunk-Z5Z3JHJY.js";
+import "./chunk-KIOXTQQL.js";
+import "./chunk-35H7GVNR.js";
+import "./chunk-AE3P3F6W.js";
+import "./chunk-TPI73L57.js";
+import "./chunk-722LQO64.js";
+import "./chunk-SUJERP5I.js";
+import "./chunk-CI4R6P2B.js";
+import "./chunk-XU2YXCDL.js";
+import "./chunk-ETHFACAB.js";
+import "./chunk-THKDVSEC.js";
+import "./chunk-UFMN76QD.js";
+import "./chunk-LH5VCGLB.js";
+import "./chunk-6S5FPUS7.js";
+import "./chunk-EXXICUIW.js";
+import "./chunk-QARAGUXX.js";
+import "./chunk-DEBI37QB.js";
+import "./chunk-ER5JW2QZ.js";
+import "./chunk-CGFZGR7G.js";
+import "./chunk-P5KJURUR.js";
+import "./chunk-WMUWEO2C.js";
+import "./chunk-BKTQAYO2.js";
+import "./chunk-OO3TAHO5.js";
+import "./chunk-EGEI2RQA.js";
+import "./chunk-ZTRINFM2.js";
+import "./chunk-ZNC5T65N.js";
+import "./chunk-7KUCBNLB.js";
+import "./chunk-A5MNH4ER.js";
+import "./chunk-BCQXEZPJ.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  createDefaultToolRegistry
+};

package/dist/deliver-task-KONV4C4M.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  __expirePostCommitReviewCooldown,
+  collectCurrentDirtyFiles,
+  createDeliverTaskTool,
+  createStageMarker,
+  detectMissingVisualVerify,
+  detectSymptomPatch,
+  formatReviewOutcomeLines,
+  parseLearnedEntries,
+  resetPostCommitReviewCooldown
+} from "./chunk-JBZHIC6T.js";
+import "./chunk-KWVTXT5B.js";
+import "./chunk-AERM3VGP.js";
+import "./chunk-RK3JHWPT.js";
+import "./chunk-NH6VIOAR.js";
+import "./chunk-S4K4L6IM.js";
+import "./chunk-TVHW77C7.js";
+import "./chunk-T3ED6BY2.js";
+import "./chunk-ZU7JZCVP.js";
+import "./chunk-LA6IPTGH.js";
+import "./chunk-HBVF6BWO.js";
+import "./chunk-4QJ3Y5JM.js";
+import "./chunk-CGOADM2X.js";
+import "./chunk-ZMZCZNKU.js";
+import "./chunk-3C3R7JXY.js";
+import "./chunk-6HSVXHCZ.js";
+import "./chunk-ADIVZ2D5.js";
+import "./chunk-Z5Z3JHJY.js";
+import "./chunk-35H7GVNR.js";
+import "./chunk-2E6CK2RC.js";
+import "./chunk-ZO3I3A7O.js";
+import "./chunk-CI4R6P2B.js";
+import "./chunk-THKDVSEC.js";
+import "./chunk-UFMN76QD.js";
+import "./chunk-ER5JW2QZ.js";
+import "./chunk-CGFZGR7G.js";
+import "./chunk-P5KJURUR.js";
+import "./chunk-WMUWEO2C.js";
+import "./chunk-BKTQAYO2.js";
+import "./chunk-OO3TAHO5.js";
+import "./chunk-7KUCBNLB.js";
+import "./chunk-A5MNH4ER.js";
+import "./chunk-BCQXEZPJ.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  __expirePostCommitReviewCooldown,
+  collectCurrentDirtyFiles,
+  createDeliverTaskTool,
+  createStageMarker,
+  detectMissingVisualVerify,
+  detectSymptomPatch,
+  formatReviewOutcomeLines,
+  parseLearnedEntries,
+  resetPostCommitReviewCooldown
+};