@akasecurity/cli 0.9.0-rc1 → 0.9.1

package/dist/cli.js

@@ -750,18 +750,1420 @@ function installAgentPlugin(agentId, mode = "capture") {
   return run("claude", ["plugin", "install", resolved.ref], mode);
 }
 
-// ../packages/local-ops/src/fs-scan.ts
-import { createHash, randomUUID } from "crypto";
-import { readdirSync, readFileSync as readFileSync2, statSync } from "fs";
-import { join as join2, relative, sep } from "path";
+// ../packages/local-ops/src/egress-record.ts
+import { statSync as statSync4 } from "fs";
+import { dirname as dirname4, relative as relative2, resolve } from "path";
+
+// ../packages/detections/src/egress/registry.ts
+var EXTRACTOR_VERSION = "1";
+var PROVIDER_REGISTRY = [
+  {
+    id: "stripe",
+    name: "Stripe",
+    category: "Payments",
+    hostSuffixes: ["stripe.com"],
+    apiBase: "https://api.stripe.com",
+    defaultDataClasses: ["pii", "customer"],
+    sdks: {
+      npm: ["stripe"],
+      pypi: ["stripe"],
+      go: ["github.com/stripe/stripe-go"],
+      maven: ["com.stripe"],
+      rubygems: ["stripe"],
+      composer: ["stripe/stripe-php"],
+      nuget: ["Stripe.net"]
+    }
+  },
+  {
+    id: "datadog",
+    name: "Datadog",
+    category: "Observability",
+    hostSuffixes: ["datadoghq.com", "datadoghq.eu"],
+    apiBase: "https://api.datadoghq.com",
+    defaultDataClasses: ["telemetry", "logs", "metrics"],
+    sdks: {
+      npm: ["dd-trace", "@datadog/browser-logs"],
+      pypi: ["datadog", "ddtrace"],
+      go: ["github.com/DataDog/dd-trace-go"],
+      maven: ["com.datadoghq"],
+      rubygems: ["ddtrace", "dogapi"],
+      nuget: ["Datadog.Trace"]
+    }
+  },
+  {
+    id: "newrelic",
+    name: "New Relic",
+    category: "Observability",
+    hostSuffixes: ["newrelic.com", "nr-data.net"],
+    apiBase: "https://api.newrelic.com",
+    defaultDataClasses: ["telemetry", "logs", "metrics"],
+    sdks: {
+      npm: ["newrelic"],
+      pypi: ["newrelic"],
+      go: ["github.com/newrelic/go-agent"],
+      maven: ["com.newrelic.agent.java"],
+      rubygems: ["newrelic_rpm"],
+      nuget: ["NewRelic.Agent"]
+    }
+  },
+  {
+    id: "sentry",
+    name: "Sentry",
+    category: "Error tracking",
+    hostSuffixes: ["sentry.io"],
+    apiBase: "https://sentry.io",
+    defaultDataClasses: ["source", "telemetry"],
+    sdks: {
+      npm: ["@sentry/node", "@sentry/react", "@sentry/nextjs"],
+      pypi: ["sentry-sdk"],
+      go: ["github.com/getsentry/sentry-go"],
+      maven: ["io.sentry"],
+      rubygems: ["sentry-ruby"],
+      cargo: ["sentry"],
+      composer: ["sentry/sentry"],
+      nuget: ["Sentry"]
+    }
+  },
+  {
+    id: "openai",
+    name: "OpenAI",
+    category: "LLM provider",
+    hostSuffixes: ["openai.com"],
+    apiBase: "https://api.openai.com",
+    defaultDataClasses: ["pii", "source"],
+    sdks: {
+      npm: ["openai"],
+      pypi: ["openai"],
+      go: ["github.com/sashabaranov/go-openai"],
+      maven: ["com.openai"],
+      rubygems: ["ruby-openai"],
+      cargo: ["async-openai"],
+      composer: ["openai-php/client"],
+      nuget: ["OpenAI"]
+    }
+  },
+  {
+    id: "anthropic",
+    name: "Anthropic",
+    category: "LLM provider",
+    hostSuffixes: ["anthropic.com"],
+    apiBase: "https://api.anthropic.com",
+    defaultDataClasses: ["pii", "source"],
+    sdks: {
+      npm: ["@anthropic-ai/sdk"],
+      pypi: ["anthropic"],
+      go: ["github.com/anthropics/anthropic-sdk-go"],
+      nuget: ["Anthropic.SDK"]
+    }
+  },
+  {
+    id: "aws",
+    name: "Amazon Web Services",
+    category: "Cloud platform",
+    hostSuffixes: ["amazonaws.com"],
+    apiBase: "https://s3.amazonaws.com",
+    defaultDataClasses: ["secrets", "customer"],
+    sdks: {
+      npm: ["@aws-sdk/client-s3", "aws-sdk"],
+      pypi: ["boto3"],
+      go: ["github.com/aws/aws-sdk-go", "github.com/aws/aws-sdk-go-v2"],
+      maven: ["com.amazonaws", "software.amazon.awssdk"],
+      rubygems: ["aws-sdk-s3"],
+      cargo: ["aws-sdk-s3"],
+      nuget: ["AWSSDK.S3"]
+    }
+  },
+  {
+    id: "gcp",
+    name: "Google Cloud",
+    category: "Cloud platform",
+    hostSuffixes: ["googleapis.com"],
+    apiBase: "https://storage.googleapis.com",
+    defaultDataClasses: ["customer", "logs"],
+    sdks: {
+      npm: ["@google-cloud/storage"],
+      pypi: ["google-cloud-storage"],
+      go: ["cloud.google.com/go"],
+      maven: ["com.google.cloud"],
+      rubygems: ["google-cloud-storage"],
+      nuget: ["Google.Cloud.Storage.V1"]
+    }
+  },
+  {
+    id: "azure",
+    name: "Microsoft Azure",
+    category: "Cloud platform",
+    hostSuffixes: ["azure.com", "windows.net"],
+    apiBase: "https://management.azure.com",
+    defaultDataClasses: ["customer", "logs"],
+    sdks: {
+      npm: ["@azure/storage-blob"],
+      pypi: ["azure-storage-blob"],
+      go: ["github.com/Azure/azure-sdk-for-go"],
+      maven: ["com.azure"],
+      rubygems: ["azure-storage-blob"],
+      nuget: ["Azure.Storage.Blobs"]
+    }
+  },
+  {
+    id: "slack",
+    name: "Slack",
+    category: "Notifications",
+    hostSuffixes: ["slack.com"],
+    apiBase: "https://slack.com/api",
+    defaultDataClasses: ["logs"],
+    sdks: {
+      npm: ["@slack/web-api"],
+      pypi: ["slack-sdk"],
+      go: ["github.com/slack-go/slack"],
+      maven: ["com.slack.api"],
+      rubygems: ["slack-ruby-client"],
+      composer: ["slack-php/slack-api"],
+      nuget: ["SlackNet"]
+    }
+  },
+  {
+    id: "segment",
+    name: "Segment",
+    category: "Analytics",
+    hostSuffixes: ["segment.io", "segment.com"],
+    apiBase: "https://api.segment.io",
+    defaultDataClasses: ["customer"],
+    sdks: {
+      npm: ["@segment/analytics-node", "analytics-node"],
+      pypi: ["segment-analytics-python"],
+      go: ["github.com/segmentio/analytics-go"],
+      maven: ["com.segment.analytics.java"],
+      rubygems: ["analytics-ruby"],
+      nuget: ["Analytics"]
+    }
+  },
+  {
+    id: "twilio",
+    name: "Twilio",
+    category: "Communications",
+    hostSuffixes: ["twilio.com"],
+    apiBase: "https://api.twilio.com",
+    defaultDataClasses: ["pii", "customer"],
+    sdks: {
+      npm: ["twilio"],
+      pypi: ["twilio"],
+      go: ["github.com/twilio/twilio-go"],
+      maven: ["com.twilio.sdk"],
+      rubygems: ["twilio-ruby"],
+      composer: ["twilio/sdk"],
+      nuget: ["Twilio"]
+    }
+  },
+  {
+    id: "sendgrid",
+    name: "SendGrid",
+    category: "Email",
+    hostSuffixes: ["sendgrid.com"],
+    apiBase: "https://api.sendgrid.com",
+    defaultDataClasses: ["pii"],
+    sdks: {
+      npm: ["@sendgrid/mail"],
+      pypi: ["sendgrid"],
+      go: ["github.com/sendgrid/sendgrid-go"],
+      maven: ["com.sendgrid"],
+      rubygems: ["sendgrid-ruby"],
+      composer: ["sendgrid/sendgrid"],
+      nuget: ["SendGrid"]
+    }
+  },
+  {
+    id: "mailgun",
+    name: "Mailgun",
+    category: "Email",
+    hostSuffixes: ["mailgun.net"],
+    apiBase: "https://api.mailgun.net",
+    defaultDataClasses: ["pii"],
+    sdks: {
+      npm: ["mailgun.js"],
+      pypi: ["mailgun"],
+      rubygems: ["mailgun-ruby"],
+      composer: ["mailgun/mailgun-php"],
+      nuget: ["Mailgun"]
+    }
+  },
+  {
+    id: "mixpanel",
+    name: "Mixpanel",
+    category: "Analytics",
+    hostSuffixes: ["mixpanel.com"],
+    apiBase: "https://api.mixpanel.com",
+    defaultDataClasses: ["customer", "telemetry"],
+    sdks: {
+      npm: ["mixpanel"],
+      pypi: ["mixpanel"],
+      rubygems: ["mixpanel-ruby"],
+      nuget: ["Mixpanel"]
+    }
+  },
+  {
+    id: "amplitude",
+    name: "Amplitude",
+    category: "Analytics",
+    hostSuffixes: ["amplitude.com"],
+    apiBase: "https://api2.amplitude.com",
+    defaultDataClasses: ["customer", "telemetry"],
+    sdks: {
+      npm: ["@amplitude/analytics-node"],
+      pypi: ["amplitude-analytics"],
+      nuget: ["Amplitude"]
+    }
+  },
+  {
+    id: "posthog",
+    name: "PostHog",
+    category: "Analytics",
+    hostSuffixes: ["posthog.com"],
+    apiBase: "https://us.i.posthog.com",
+    defaultDataClasses: ["customer", "telemetry"],
+    sdks: {
+      npm: ["posthog-node", "posthog-js"],
+      pypi: ["posthog"],
+      go: ["github.com/posthog/posthog-go"],
+      rubygems: ["posthog-ruby"],
+      composer: ["posthog/posthog-php"],
+      nuget: ["PostHog"]
+    }
+  },
+  {
+    id: "honeycomb",
+    name: "Honeycomb",
+    category: "Observability",
+    hostSuffixes: ["honeycomb.io"],
+    apiBase: "https://api.honeycomb.io",
+    defaultDataClasses: ["telemetry", "metrics"],
+    sdks: {
+      npm: ["libhoney"],
+      pypi: ["libhoney"],
+      go: ["github.com/honeycombio/libhoney-go"],
+      rubygems: ["libhoney"]
+    }
+  },
+  {
+    id: "grafana",
+    name: "Grafana Cloud",
+    category: "Observability",
+    hostSuffixes: ["grafana.net"],
+    apiBase: "https://grafana.net",
+    defaultDataClasses: ["logs", "metrics"],
+    sdks: {
+      npm: ["@grafana/faro-web-sdk"]
+    }
+  },
+  {
+    id: "splunk",
+    name: "Splunk",
+    category: "Observability",
+    hostSuffixes: ["splunkcloud.com", "splunk.com"],
+    apiBase: "https://http-inputs.splunkcloud.com",
+    defaultDataClasses: ["logs"],
+    sdks: {
+      npm: ["splunk-logging"],
+      pypi: ["splunk-sdk"],
+      maven: ["com.splunk"],
+      nuget: ["Splunk.Logging.Common"]
+    }
+  },
+  {
+    id: "pagerduty",
+    name: "PagerDuty",
+    category: "Incident response",
+    hostSuffixes: ["pagerduty.com"],
+    apiBase: "https://api.pagerduty.com",
+    defaultDataClasses: ["logs"],
+    sdks: {
+      npm: ["@pagerduty/pdjs"],
+      pypi: ["pdpyras"],
+      go: ["github.com/PagerDuty/go-pagerduty"],
+      rubygems: ["pagerduty"]
+    }
+  },
+  {
+    id: "github",
+    name: "GitHub",
+    category: "Developer platform",
+    hostSuffixes: ["github.com", "githubusercontent.com"],
+    apiBase: "https://api.github.com",
+    defaultDataClasses: ["source"],
+    sdks: {
+      npm: ["@octokit/rest", "octokit"],
+      pypi: ["pygithub"],
+      go: ["github.com/google/go-github"],
+      maven: ["org.kohsuke.github-api"],
+      rubygems: ["octokit"],
+      cargo: ["octocrab"],
+      composer: ["knplabs/github-api"],
+      nuget: ["Octokit"]
+    }
+  },
+  {
+    id: "gitlab",
+    name: "GitLab",
+    category: "Developer platform",
+    hostSuffixes: ["gitlab.com"],
+    apiBase: "https://gitlab.com/api",
+    defaultDataClasses: ["source"],
+    sdks: {
+      npm: ["@gitbeaker/rest"],
+      pypi: ["python-gitlab"],
+      go: ["gitlab.com/gitlab-org/api/client-go"],
+      rubygems: ["gitlab"],
+      nuget: ["GitLabApiClient"]
+    }
+  },
+  {
+    id: "auth0",
+    name: "Auth0",
+    category: "Identity",
+    hostSuffixes: ["auth0.com"],
+    apiBase: "https://login.auth0.com",
+    defaultDataClasses: ["pii"],
+    sdks: {
+      npm: ["auth0"],
+      pypi: ["auth0-python"],
+      go: ["github.com/auth0/go-auth0"],
+      maven: ["com.auth0"],
+      rubygems: ["auth0"],
+      composer: ["auth0/auth0-php"],
+      nuget: ["Auth0.ManagementApi"]
+    }
+  },
+  {
+    id: "okta",
+    name: "Okta",
+    category: "Identity",
+    hostSuffixes: ["okta.com", "oktapreview.com"],
+    apiBase: "https://login.okta.com",
+    defaultDataClasses: ["pii"],
+    sdks: {
+      npm: ["@okta/okta-sdk-nodejs"],
+      pypi: ["okta"],
+      go: ["github.com/okta/okta-sdk-golang"],
+      maven: ["com.okta.sdk"],
+      nuget: ["Okta.Sdk"]
+    }
+  },
+  {
+    id: "clerk",
+    name: "Clerk",
+    category: "Identity",
+    hostSuffixes: ["clerk.com", "clerk.dev"],
+    apiBase: "https://api.clerk.com",
+    defaultDataClasses: ["pii"],
+    sdks: {
+      npm: ["@clerk/backend", "@clerk/nextjs"],
+      pypi: ["clerk-backend-api"],
+      go: ["github.com/clerk/clerk-sdk-go"]
+    }
+  },
+  {
+    id: "supabase",
+    name: "Supabase",
+    category: "Backend platform",
+    hostSuffixes: ["supabase.co", "supabase.com"],
+    apiBase: "https://api.supabase.com",
+    defaultDataClasses: ["pii", "customer"],
+    sdks: {
+      npm: ["@supabase/supabase-js"],
+      pypi: ["supabase"],
+      cargo: ["postgrest"]
+    }
+  },
+  {
+    id: "firebase",
+    name: "Firebase",
+    category: "Backend platform",
+    hostSuffixes: ["firebaseio.com", "firebase.google.com"],
+    apiBase: "https://firebaseio.com",
+    defaultDataClasses: ["customer"],
+    sdks: {
+      npm: ["firebase", "firebase-admin"],
+      pypi: ["firebase-admin"],
+      go: ["firebase.google.com/go"],
+      maven: ["com.google.firebase"]
+    }
+  },
+  {
+    id: "mongodb-atlas",
+    name: "MongoDB Atlas",
+    category: "Database SaaS",
+    hostSuffixes: ["mongodb.net", "mongodb.com"],
+    apiBase: "https://cloud.mongodb.com",
+    defaultDataClasses: ["customer"],
+    sdks: {
+      npm: ["mongodb"],
+      pypi: ["pymongo"],
+      go: ["go.mongodb.org/mongo-driver"],
+      maven: ["org.mongodb"],
+      rubygems: ["mongo"],
+      cargo: ["mongodb"],
+      nuget: ["MongoDB.Driver"]
+    }
+  },
+  {
+    id: "planetscale",
+    name: "PlanetScale",
+    category: "Database SaaS",
+    hostSuffixes: ["psdb.cloud", "planetscale.com"],
+    apiBase: "https://api.planetscale.com",
+    defaultDataClasses: ["customer"],
+    sdks: {
+      npm: ["@planetscale/database"],
+      go: ["github.com/planetscale/planetscale-go"]
+    }
+  },
+  {
+    id: "algolia",
+    name: "Algolia",
+    category: "Search SaaS",
+    hostSuffixes: ["algolia.net", "algolianet.com"],
+    apiBase: "https://algolia.net",
+    defaultDataClasses: ["customer"],
+    sdks: {
+      npm: ["algoliasearch"],
+      pypi: ["algoliasearch"],
+      go: ["github.com/algolia/algoliasearch-client-go"],
+      maven: ["com.algolia"],
+      rubygems: ["algolia"],
+      composer: ["algolia/algoliasearch-client-php"],
+      nuget: ["Algolia.Search"]
+    }
+  },
+  {
+    id: "cloudflare",
+    name: "Cloudflare",
+    category: "CDN / edge",
+    hostSuffixes: ["cloudflare.com", "workers.dev"],
+    apiBase: "https://api.cloudflare.com",
+    defaultDataClasses: ["logs"],
+    sdks: {
+      npm: ["cloudflare"],
+      pypi: ["cloudflare"],
+      go: ["github.com/cloudflare/cloudflare-go"],
+      nuget: ["CloudFlare.Client"]
+    }
+  },
+  {
+    id: "huggingface",
+    name: "Hugging Face",
+    category: "LLM provider",
+    hostSuffixes: ["huggingface.co"],
+    apiBase: "https://api-inference.huggingface.co",
+    defaultDataClasses: ["source"],
+    sdks: {
+      npm: ["@huggingface/inference"],
+      pypi: ["huggingface-hub", "transformers"],
+      rubygems: ["hugging-face"]
+    }
+  },
+  {
+    id: "cohere",
+    name: "Cohere",
+    category: "LLM provider",
+    hostSuffixes: ["cohere.com", "cohere.ai"],
+    apiBase: "https://api.cohere.com",
+    defaultDataClasses: ["pii", "source"],
+    sdks: {
+      npm: ["cohere-ai"],
+      pypi: ["cohere"],
+      go: ["github.com/cohere-ai/cohere-go"]
+    }
+  },
+  {
+    id: "mistral",
+    name: "Mistral AI",
+    category: "LLM provider",
+    hostSuffixes: ["mistral.ai"],
+    apiBase: "https://api.mistral.ai",
+    defaultDataClasses: ["pii", "source"],
+    sdks: {
+      npm: ["@mistralai/mistralai"],
+      pypi: ["mistralai"],
+      go: ["github.com/gage-technologies/mistral-go"]
+    }
+  }
+];
+var EGRESS_VERSION_MATERIAL = `${EXTRACTOR_VERSION}
+${JSON.stringify(PROVIDER_REGISTRY)}`;
+var INTERNAL_TLDS = ["internal", "local", "corp", "lan", "intranet", "home.arpa"];
+var EXCLUDED_HOST_SUFFIXES = [
+  "localhost",
+  "test",
+  "example",
+  "invalid",
+  "example.com",
+  "example.org",
+  "example.net",
+  "w3.org",
+  "schemas.openxmlformats.org",
+  "schemas.microsoft.com",
+  "schemas.android.com",
+  "maven.apache.org"
+];
+function hostMatchesSuffix(host, suffix) {
+  return host === suffix || host.endsWith(`.${suffix}`);
+}
+function isValidIPv4(host) {
+  const parts = host.split(".");
+  if (parts.length !== 4) return false;
+  return parts.every((part) => /^\d{1,3}$/.test(part) && Number(part) <= 255);
+}
+function isPrivateOrReservedIPv4(host) {
+  const octets = host.split(".").map(Number);
+  const a = octets[0];
+  const b = octets[1];
+  if (a === void 0 || b === void 0) return false;
+  if (a === 0 || a === 10 || a === 127 || a >= 224) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  return false;
+}
+function normalizeIPv6Literal(host) {
+  const unbracketed = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+  const zoneIndex = unbracketed.indexOf("%");
+  const unzoned = zoneIndex === -1 ? unbracketed : unbracketed.slice(0, zoneIndex);
+  return unzoned.toLowerCase();
+}
+var IPV6_HEX_GROUP = /^[0-9a-f]{1,4}$/;
+function isValidIPv6(host) {
+  const h = normalizeIPv6Literal(host);
+  if (!h.includes(":")) return false;
+  const collapsedHalves = h.split("::");
+  if (collapsedHalves.length > 2) return false;
+  const sides = collapsedHalves.length === 2 ? collapsedHalves : [h];
+  const groups = sides.flatMap((side) => side === "" ? [] : side.split(":"));
+  if (!groups.every((g) => IPV6_HEX_GROUP.test(g))) return false;
+  return collapsedHalves.length === 2 ? groups.length <= 7 : groups.length === 8;
+}
+function isPrivateOrReservedIPv6(host) {
+  const h = normalizeIPv6Literal(host);
+  if (h === "::" || h === "::1") return true;
+  const firstGroup = (h.split(":")[0] ?? "").padStart(4, "0");
+  if (firstGroup.startsWith("fc") || firstGroup.startsWith("fd")) return true;
+  if (firstGroup.startsWith("fe") && "89ab".includes(firstGroup[2] ?? "")) return true;
+  if (firstGroup.startsWith("ff")) return true;
+  return false;
+}
+var IPV4_MAPPED_IPV6 = /^::ffff:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/;
+function ipv4MappedAddress(host) {
+  const match = IPV4_MAPPED_IPV6.exec(normalizeIPv6Literal(host));
+  return match?.[1] ?? null;
+}
+function resolveHost(host, opts) {
+  const h = host.toLowerCase();
+  if (isValidIPv4(h)) {
+    if (isPrivateOrReservedIPv4(h)) return null;
+    return { kind: "ip", trust: "ip", name: h, category: "Unresolved host", entry: null };
+  }
+  if (isValidIPv6(h)) {
+    if (isPrivateOrReservedIPv6(h)) return null;
+    return { kind: "ip", trust: "ip", name: h, category: "Unresolved host", entry: null };
+  }
+  const mappedIPv4 = ipv4MappedAddress(h);
+  if (mappedIPv4 !== null && isValidIPv4(mappedIPv4)) {
+    if (isPrivateOrReservedIPv4(mappedIPv4)) return null;
+    return { kind: "ip", trust: "ip", name: h, category: "Unresolved host", entry: null };
+  }
+  if (EXCLUDED_HOST_SUFFIXES.some((suffix) => hostMatchesSuffix(h, suffix))) return null;
+  const entry = PROVIDER_REGISTRY.find(
+    (p) => p.hostSuffixes.some((suffix) => hostMatchesSuffix(h, suffix))
+  );
+  if (entry) {
+    return {
+      kind: "provider",
+      trust: "recognized",
+      name: entry.name,
+      category: entry.category,
+      entry
+    };
+  }
+  const internalDomains = opts?.internalDomains ?? [];
+  const isInternal = !h.includes(".") && !h.includes(":") || INTERNAL_TLDS.some((tld) => hostMatchesSuffix(h, tld)) || internalDomains.some((domain2) => hostMatchesSuffix(h, domain2.toLowerCase()));
+  if (isInternal) {
+    return {
+      kind: "internal",
+      trust: "internal",
+      name: h,
+      category: "Internal services",
+      entry: null
+    };
+  }
+  return {
+    kind: "external",
+    trust: "unverified",
+    name: h,
+    category: "External domain",
+    entry: null
+  };
+}
+function resolveSdk(ecosystem, pkg) {
+  for (const entry of PROVIDER_REGISTRY) {
+    const idents = entry.sdks[ecosystem];
+    if (idents === void 0) continue;
+    if (idents.some((ident) => sdkMatches(ecosystem, pkg, ident))) return entry;
+  }
+  return null;
+}
+function sdkMatches(ecosystem, pkg, ident) {
+  switch (ecosystem) {
+    case "nuget":
+      return pkg.toLowerCase() === ident.toLowerCase();
+    case "pypi":
+      return normalizePypi(pkg) === normalizePypi(ident);
+    case "go":
+      return pkg === ident || pkg.startsWith(`${ident}/`);
+    case "maven":
+      return pkg === ident || pkg.startsWith(`${ident}.`);
+    default:
+      return pkg === ident;
+  }
+}
+function normalizePypi(name) {
+  return name.toLowerCase().replace(/[-_.]+/g, "-");
+}
+
+// ../packages/detections/src/egress/extract.ts
+var EGRESS_CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".java",
+  ".rb",
+  ".cs",
+  ".php",
+  ".go",
+  ".rs"
+]);
+var SNIPPET_MAX = 200;
+var MASK = "\u2022\u2022\u2022\u2022";
+var URL_CANDIDATE = /(https?|wss?|sftp|grpcs?|smtp):\/\/(?:[^\s'"`<>()[\]{},;]|\$\{[^}\s]{1,64}\}|\{[A-Za-z_]\w{0,63}\}|%[sd])+/gi;
+var PLACEHOLDER = /\$\{[^}\s]{1,64}\}|\{[A-Za-z_]\w{0,63}\}|%[sd]/g;
+var VAR_TOKEN = "${var}";
+var VAR_SENTINEL = "akaegressvar0";
+var TRAILING_PUNCTUATION = /[.,;:'"]+$/;
+var TRANSPORT_BY_SCHEME = {
+  http: "http",
+  https: "https",
+  ws: "ws",
+  wss: "wss",
+  sftp: "sftp",
+  grpc: "grpc",
+  grpcs: "grpc",
+  smtp: "smtp"
+};
+var BEFORE_WINDOW = 200;
+var AFTER_WINDOW = 300;
+var VERB_METHOD_OPENER = /\.\s*(get|post|put|delete)\s*\(\s*['"`]*$/i;
+var VERB_FIRST_ARGUMENT = /["'](GET|POST|PUT|DELETE)["']\s*,([^)\]};]{0,150})$/i;
+var OPTIONS_METHOD = /method\s*[:=]\s*['"](GET|POST|PUT|DELETE)/i;
+var CLIENT_OPENER = /\b(fetch|urlopen|got|ky)\s*\(\s*['"`]*$/i;
+var ANY_METHOD_KEY = /\bmethod\s*[:=]/i;
+var STATEMENT_BREAK = /;|\n\s*(?:(?:const|let|var|val|function|func|fn|def|class|return|export|import|if|for|while|switch|try|public|private)\b|\w+\s*=[^=])/;
+var IPV4_CANDIDATE = /\b(?:\d{1,3}\.){3}\d{1,3}(?::\d{1,5})?\b/g;
+var IP_HOST_CONTEXT = /\b(host|hostname|server|address|endpoint|ip|url|uri)\b/i;
+var IP_SFTP_CONTEXT = /\bs(ftp|cp|sh)\b/i;
+var IP_SMTP_CONTEXT = /\b(smtp|mail)\b/i;
+var SECRET_KEY_NAMES = "api[_-]?key|apikey|private[_-]?key|access[_-]?key|access[_-]?token|token|secret|credentials?|password|passwd|pwd|authorization|sig|signature|sas|assertion";
+var AUTH_SCHEMES = "Bearer|Basic|Token|Digest|ApiKey|SSWS|AWS4-HMAC-SHA256";
+var USERINFO = /:\/\/[^@/\s]+@/g;
+var SECRET_VALUE = new RegExp(
+  `((?:${SECRET_KEY_NAMES})['"\`]?\\s*[:=]\\s*['"\`]?)(?!(?:${AUTH_SCHEMES})[\\s'"\`])[^\\s'"\`&]+`,
+  "gi"
+);
+var AUTH_SCHEME_VALUE = new RegExp(
+  `((?:${SECRET_KEY_NAMES})['"\`]?\\s*[:=]\\s*['"\`]?)(${AUTH_SCHEMES})\\s+[^\\s'"\`]+`,
+  "gi"
+);
+var BEARER_TOKEN = /\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi;
+var WEBHOOK_SECRET_PATHS = [
+  { hosts: ["hooks.slack.com"], prefix: "/services/" },
+  {
+    hosts: ["discord.com", "discordapp.com", "ptb.discord.com", "canary.discord.com"],
+    prefix: "/api/webhooks/"
+  },
+  { hosts: ["hooks.zapier.com"], prefix: "/hooks/" },
+  { hosts: ["outlook.office.com", "outlook.office365.com"], prefix: "/webhook/" }
+];
+function escapeRegExp(literal2) {
+  return literal2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var WEBHOOK_URL = new RegExp(
+  `(https?://(?:${WEBHOOK_SECRET_PATHS.flatMap(
+    (entry) => entry.hosts.map((host) => `${escapeRegExp(host)}${escapeRegExp(entry.prefix)}`)
+  ).join("|")}))[^\\s'"\`<>()[\\]{},;]+`,
+  "gi"
+);
+function maskWebhookPath(host, pathname) {
+  for (const entry of WEBHOOK_SECRET_PATHS) {
+    if (entry.hosts.includes(host) && pathname.startsWith(entry.prefix)) {
+      return `${entry.prefix}${MASK}`;
+    }
+  }
+  return pathname;
+}
+var VENDORED_PATH = /(^|\/)(vendor|third_party|external)\//;
+function isVendoredPath(file2) {
+  return VENDORED_PATH.test(file2);
+}
+function redactLine(line) {
+  return line.trim().replace(USERINFO, "://").replace(WEBHOOK_URL, `$1${MASK}`).replace(SECRET_VALUE, `$1${MASK}`).replace(AUTH_SCHEME_VALUE, `$1$2 ${MASK}`).replace(BEARER_TOKEN, `Bearer ${MASK}`);
+}
+function redactSnippet(line, anchor = 0) {
+  const redacted = redactLine(line);
+  if (redacted.length <= SNIPPET_MAX) return redacted;
+  const lead = line.length - line.trimStart().length;
+  const trimmed = line.trim();
+  const mapped = redacted.length === trimmed.length ? anchor - lead : redactLine(trimmed.slice(0, Math.max(0, anchor - lead))).length;
+  const start = Math.min(
+    Math.max(0, mapped - Math.floor(SNIPPET_MAX / 2)),
+    redacted.length - SNIPPET_MAX
+  );
+  return redacted.slice(start, start + SNIPPET_MAX);
+}
+function extractEgress(text) {
+  const lineStarts = lineStartOffsets(text);
+  const urlSpans = [];
+  const hits = [];
+  const lineTextOf = memoizeByLine((index) => lineTextAt(text, lineStarts, index));
+  const ipContextOf = memoizeByLine((index) => ipLineContext(lineTextOf(index)));
+  const snippetAt = (index, offset) => redactSnippet(lineTextOf(index), offset - (lineStarts[index] ?? 0));
+  for (const match of text.matchAll(URL_CANDIDATE)) {
+    const start = match.index;
+    const matched = match[0];
+    urlSpans.push([start, start + matched.length]);
+    const scheme = match[1];
+    if (scheme === void 0) continue;
+    const candidate = matched.replace(TRAILING_PUNCTUATION, "");
+    if (candidate === "") continue;
+    const parsed = parseCandidate(candidate, scheme);
+    if (parsed === null) continue;
+    const index = lineIndexAt(lineStarts, start);
+    hits.push({
+      ...parsed,
+      method: inferMethod(text, start, start + matched.length),
+      line: index + 1,
+      snippet: snippetAt(index, start)
+    });
+  }
+  for (const match of text.matchAll(IPV4_CANDIDATE)) {
+    const start = match.index;
+    if (isInsideSpan(urlSpans, start)) continue;
+    const index = lineIndexAt(lineStarts, start);
+    const parsed = parseBareIp(match[0], ipContextOf(index));
+    if (parsed === null) continue;
+    hits.push({ ...parsed, method: "REF", line: index + 1, snippet: snippetAt(index, start) });
+  }
+  return hits.sort(compareHits);
+}
+function parseCandidate(candidate, scheme) {
+  const transport = TRANSPORT_BY_SCHEME[scheme.toLowerCase()];
+  if (transport === void 0) return null;
+  let placeholders2 = 0;
+  const normalized = candidate.replace(PLACEHOLDER, () => {
+    placeholders2 += 1;
+    return VAR_TOKEN;
+  });
+  let parsed;
+  try {
+    parsed = new URL(normalized.split(VAR_TOKEN).join(VAR_SENTINEL));
+  } catch {
+    return null;
+  }
+  const host = parsed.hostname.toLowerCase();
+  if (host === "" || host.includes(VAR_SENTINEL)) return null;
+  const authority = parsed.host.toLowerCase();
+  const path = maskWebhookPath(host, parsed.pathname);
+  const url2 = `${transport}://${authority}${path}`.split(VAR_SENTINEL).join(VAR_TOKEN);
+  return {
+    url: url2,
+    host,
+    port: parsed.port === "" ? null : Number(parsed.port),
+    transport,
+    template: placeholders2 > 0
+  };
+}
+function parseBareIp(candidate, context) {
+  const [address, port] = splitPort(candidate);
+  if (!isValidIPv4(address) || isPrivateOrReservedIPv4(address)) return null;
+  if (!context.named) return null;
+  const { transport } = context;
+  return {
+    url: `${transport}://${address}${port === null ? "" : `:${String(port)}`}`,
+    host: address,
+    port,
+    transport,
+    template: false
+  };
+}
+function ipLineContext(line) {
+  const context = identifierWords(line);
+  let transport = "http";
+  if (IP_SFTP_CONTEXT.test(context)) transport = "sftp";
+  else if (IP_SMTP_CONTEXT.test(context)) transport = "smtp";
+  return { named: IP_HOST_CONTEXT.test(context), transport };
+}
+function isInsideSpan(spans, offset) {
+  let low = 0;
+  let high = spans.length - 1;
+  let found = -1;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const span2 = spans[mid];
+    if (span2 === void 0) break;
+    if (span2[0] <= offset) {
+      found = mid;
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  const span = found === -1 ? void 0 : spans[found];
+  return span !== void 0 && offset < span[1];
+}
+function splitPort(candidate) {
+  const colon = candidate.indexOf(":");
+  if (colon === -1) return [candidate, null];
+  return [candidate.slice(0, colon), Number(candidate.slice(colon + 1))];
+}
+function identifierWords(line) {
+  return line.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2");
+}
+function inferMethod(text, start, end) {
+  const before = text.slice(Math.max(0, start - BEFORE_WINDOW), start);
+  const after = text.slice(end, end + AFTER_WINDOW);
+  const opener = VERB_METHOD_OPENER.exec(before);
+  if (opener?.[1] !== void 0) return verbOf(opener[1]);
+  const firstArgument = VERB_FIRST_ARGUMENT.exec(before);
+  if (firstArgument?.[1] !== void 0 && !STATEMENT_BREAK.test(firstArgument[2] ?? "")) {
+    return verbOf(firstArgument[1]);
+  }
+  const options = OPTIONS_METHOD.exec(after);
+  if (options?.[1] !== void 0 && !STATEMENT_BREAK.test(after.slice(0, options.index))) {
+    return verbOf(options[1]);
+  }
+  if (CLIENT_OPENER.test(before)) {
+    const close = callCloseIndex(after);
+    if (close !== -1 && isSoleArgument(after, close) && !ANY_METHOD_KEY.test(after.slice(0, close))) {
+      return "GET";
+    }
+  }
+  return "REF";
+}
+function verbOf(raw) {
+  return raw.toUpperCase();
+}
+function callCloseIndex(span) {
+  let depth = 1;
+  for (let i = 0; i < span.length; i += 1) {
+    const char = span[i];
+    if (char === "(") depth += 1;
+    else if (char === ")") {
+      depth -= 1;
+      if (depth === 0) return i + 1;
+    }
+  }
+  return -1;
+}
+function isSoleArgument(span, close) {
+  const between = span.slice(0, close - 1).trimEnd();
+  const withoutTrailingComma = between.endsWith(",") ? between.slice(0, -1) : between;
+  return !withoutTrailingComma.includes(",");
+}
+function memoizeByLine(compute) {
+  const cache = /* @__PURE__ */ new Map();
+  return (index) => {
+    const cached2 = cache.get(index);
+    if (cached2 !== void 0) return cached2;
+    const value = compute(index);
+    cache.set(index, value);
+    return value;
+  };
+}
+function lineStartOffsets(text) {
+  const starts = [0];
+  for (let i = 0; i < text.length; i += 1) {
+    if (text[i] === "\n") starts.push(i + 1);
+  }
+  return starts;
+}
+function lineIndexAt(starts, offset) {
+  let low = 0;
+  let high = starts.length - 1;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if ((starts[mid] ?? 0) <= offset) low = mid;
+    else high = mid - 1;
+  }
+  return low;
+}
+function lineTextAt(text, starts, index) {
+  const start = starts[index] ?? 0;
+  const next = starts[index + 1];
+  return next === void 0 ? text.slice(start) : text.slice(start, next - 1);
+}
+function compareHits(a, b) {
+  if (a.line !== b.line) return a.line - b.line;
+  if (a.url !== b.url) return a.url < b.url ? -1 : 1;
+  return 0;
+}
+
+// ../packages/detections/src/egress/manifests.ts
+var LOCKFILE_BASENAMES = /* @__PURE__ */ new Set([
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "Cargo.lock",
+  "composer.lock",
+  "Gemfile.lock",
+  "poetry.lock",
+  "go.sum",
+  "packages.lock.json"
+]);
+var EXACT_KIND_BY_BASENAME = {
+  "package.json": "package.json",
+  "requirements.txt": "requirements.txt",
+  "pyproject.toml": "pyproject.toml",
+  "go.mod": "go.mod",
+  "pom.xml": "pom.xml",
+  "build.gradle": "build.gradle",
+  "build.gradle.kts": "build.gradle",
+  Gemfile: "Gemfile",
+  "Cargo.toml": "Cargo.toml",
+  "composer.json": "composer.json",
+  "packages.config": "packages.config"
+};
+function manifestKindOf(basename6) {
+  if (LOCKFILE_BASENAMES.has(basename6)) return null;
+  const exact = Object.hasOwn(EXACT_KIND_BY_BASENAME, basename6) ? EXACT_KIND_BY_BASENAME[basename6] : void 0;
+  if (exact !== void 0) return exact;
+  if (basename6.endsWith(".csproj")) return "csproj";
+  return null;
+}
+function extractManifestSdks(text, kind) {
+  switch (kind) {
+    case "package.json":
+      return extractPackageJson(text);
+    case "requirements.txt":
+      return extractRequirementsTxt(text);
+    case "pyproject.toml":
+      return extractPyprojectToml(text);
+    case "go.mod":
+      return extractGoMod(text);
+    case "pom.xml":
+      return extractPomXml(text);
+    case "build.gradle":
+      return extractBuildGradle(text);
+    case "Gemfile":
+      return extractGemfile(text);
+    case "Cargo.toml":
+      return extractCargoToml(text);
+    case "composer.json":
+      return extractComposerJson(text);
+    case "csproj":
+      return extractCsproj(text);
+    case "packages.config":
+      return extractPackagesConfig(text);
+    default:
+      return [];
+  }
+}
+function makeHit(ecosystem, pkg, line, rawLine) {
+  return { ecosystem, pkg, line, snippet: redactSnippet(rawLine) };
+}
+function extractPackageJson(text) {
+  const parsed = parseJson(text);
+  if (parsed === null) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const hits = [];
+  for (const pkg of objectKeys(parsed.dependencies)) {
+    seen.add(pkg);
+    hits.push(hitAtQuotedKey("npm", pkg, text, "dependencies"));
+  }
+  for (const pkg of objectKeys(parsed.optionalDependencies)) {
+    if (seen.has(pkg)) continue;
+    seen.add(pkg);
+    hits.push(hitAtQuotedKey("npm", pkg, text, "optionalDependencies"));
+  }
+  return hits;
+}
+var REQUIREMENTS_NAME = /^\s*([A-Za-z0-9][\w.-]*)/;
+function extractRequirementsTxt(text) {
+  const hits = [];
+  eachLine(text, (rawLine, lineNumber) => {
+    const match = REQUIREMENTS_NAME.exec(rawLine);
+    const name = match?.[1];
+    if (name === void 0) return;
+    hits.push(makeHit("pypi", normalizePypi(name), lineNumber, rawLine));
+  });
+  return hits;
+}
+var TOML_SECTION = /^\s*\[([^\]]+)\]\s*$/;
+var TOML_QUOTED = /"([^"]*)"|'([^']*)'/g;
+var PEP508_NAME = /^([A-Za-z0-9][\w.-]*)/;
+var POETRY_KEY = /^\s*([A-Za-z0-9][\w.-]*)\s*=/;
+function extractPyprojectToml(text) {
+  const hits = [];
+  let section = "";
+  let inDependenciesArray = false;
+  eachLine(text, (rawLine, lineNumber) => {
+    const sectionMatch = TOML_SECTION.exec(rawLine);
+    if (sectionMatch) {
+      section = sectionMatch[1]?.trim() ?? "";
+      inDependenciesArray = false;
+      return;
+    }
+    if (!inDependenciesArray && /^\s*dependencies\s*=\s*\[/.test(rawLine)) {
+      inDependenciesArray = true;
+    }
+    if (inDependenciesArray) {
+      for (const spec of quotedStrings(rawLine)) {
+        const name = PEP508_NAME.exec(spec)?.[1];
+        if (name !== void 0)
+          hits.push(makeHit("pypi", normalizePypi(name), lineNumber, rawLine));
+      }
+      if (rawLine.includes("]")) inDependenciesArray = false;
+      return;
+    }
+    if (section === "tool.poetry.dependencies") {
+      const key = POETRY_KEY.exec(rawLine)?.[1];
+      if (key !== void 0 && key !== "python") {
+        hits.push(makeHit("pypi", normalizePypi(key), lineNumber, rawLine));
+      }
+    }
+  });
+  return hits;
+}
+function quotedStrings(line) {
+  return [...line.matchAll(TOML_QUOTED)].map((m) => m[1] ?? m[2] ?? "");
+}
+var GO_BLOCK_OPEN = /^\s*(require|exclude|replace|retract)\s*\(/;
+var GO_BLOCK_CLOSE = /^\s*\)/;
+var GO_REQUIRE_SINGLE_LINE = /^\s*require\s+([\w./-]+)\s+v\d/;
+var GO_MODULE_VERSION_LINE = /^\s*([\w./-]+)\s+v\d/;
+function extractGoMod(text) {
+  const hits = [];
+  let blockKeyword = null;
+  eachLine(text, (rawLine, lineNumber) => {
+    if (blockKeyword === null) {
+      const open = GO_BLOCK_OPEN.exec(rawLine)?.[1];
+      if (open !== void 0) {
+        blockKeyword = open;
+        return;
+      }
+      const path = GO_REQUIRE_SINGLE_LINE.exec(rawLine)?.[1];
+      if (path !== void 0) hits.push(makeHit("go", path, lineNumber, rawLine));
+      return;
+    }
+    if (GO_BLOCK_CLOSE.test(rawLine)) {
+      blockKeyword = null;
+      return;
+    }
+    if (blockKeyword === "require") {
+      const path = GO_MODULE_VERSION_LINE.exec(rawLine)?.[1];
+      if (path !== void 0) hits.push(makeHit("go", path, lineNumber, rawLine));
+    }
+  });
+  return hits;
+}
+var POM_CONTEXT_TAGS = /* @__PURE__ */ new Set([
+  "project",
+  "parent",
+  "dependencyManagement",
+  "dependencies",
+  "dependency",
+  "build",
+  "plugins",
+  "plugin",
+  "exclusions",
+  "exclusion"
+]);
+var XML_TAG = /<(\/?)([A-Za-z][\w.-]*)([^<>]*)>/g;
+var LEADING_TEXT = /^([^<]*)/;
+function extractPomXml(text) {
+  const hits = [];
+  const stack = [];
+  let inComment = false;
+  eachLine(text, (rawLine, lineNumber) => {
+    const stripped = stripXmlComments(rawLine, inComment);
+    inComment = stripped.inComment;
+    const visible = stripped.visible;
+    for (const match of visible.matchAll(XML_TAG)) {
+      const name = match[2];
+      if (name === void 0) continue;
+      const closing = match[1] === "/";
+      const rest = match[3] ?? "";
+      const selfClosing = rest.trimEnd().endsWith("/");
+      if (closing) {
+        if (POM_CONTEXT_TAGS.has(name) && stack[stack.length - 1] === name) stack.pop();
+        continue;
+      }
+      if (selfClosing) continue;
+      if (name === "groupId") {
+        const after = visible.slice(match.index + match[0].length);
+        const value = LEADING_TEXT.exec(after)?.[1]?.trim() ?? "";
+        if (value !== "" && isProjectDependencyGroupId(stack)) {
+          hits.push(makeHit("maven", value, lineNumber, rawLine));
+        }
+        continue;
+      }
+      if (POM_CONTEXT_TAGS.has(name)) stack.push(name);
+    }
+  });
+  return hits;
+}
+function isProjectDependencyGroupId(stack) {
+  return stack[stack.length - 1] === "dependency" && stack[stack.length - 2] === "dependencies" && !stack.includes("dependencyManagement") && !stack.includes("parent") && !stack.includes("build");
+}
+var GRADLE_DEPENDENCY = /\b(?:implementation|api|compile)\b\s*[('"]*(?:platform\s*\(\s*['"])?([\w.-]+):[\w.-]+/g;
+var LINE_COMMENT = /^\s*\/\//;
+function extractBuildGradle(text) {
+  const hits = [];
+  eachLine(text, (rawLine, lineNumber) => {
+    if (LINE_COMMENT.test(rawLine)) return;
+    for (const match of rawLine.matchAll(GRADLE_DEPENDENCY)) {
+      const groupId = match[1];
+      if (groupId !== void 0) hits.push(makeHit("maven", groupId, lineNumber, rawLine));
+    }
+  });
+  return hits;
+}
+var GEMFILE_DEPENDENCY = /^\s*gem\s+['"]([\w-]+)['"]/;
+function extractGemfile(text) {
+  const hits = [];
+  eachLine(text, (rawLine, lineNumber) => {
+    const name = GEMFILE_DEPENDENCY.exec(rawLine)?.[1];
+    if (name !== void 0) hits.push(makeHit("rubygems", name, lineNumber, rawLine));
+  });
+  return hits;
+}
+var CARGO_KEY = /^([A-Za-z0-9_-]+)\s*=/;
+function extractCargoToml(text) {
+  const hits = [];
+  let mode = "none";
+  eachLine(text, (rawLine, lineNumber) => {
+    const sectionMatch = TOML_SECTION.exec(rawLine);
+    if (sectionMatch) {
+      const name = sectionMatch[1]?.trim() ?? "";
+      if (name === "dependencies") {
+        mode = "plain";
+      } else if (name.startsWith("dependencies.")) {
+        mode = "dotted";
+        const crate = name.slice("dependencies.".length);
+        if (crate !== "") hits.push(makeHit("cargo", crate, lineNumber, rawLine));
+      } else {
+        mode = "none";
+      }
+      return;
+    }
+    if (mode === "plain") {
+      const crate = CARGO_KEY.exec(rawLine)?.[1];
+      if (crate !== void 0) hits.push(makeHit("cargo", crate, lineNumber, rawLine));
+    }
+  });
+  return hits;
+}
+function extractComposerJson(text) {
+  const parsed = parseJson(text);
+  if (parsed === null) return [];
+  const pkgs = objectKeys(parsed.require).filter((pkg) => pkg !== "php" && !pkg.startsWith("ext-"));
+  return pkgs.map((pkg) => hitAtQuotedKey("composer", pkg, text, "require"));
+}
+var CSPROJ_PACKAGE_REFERENCE = /<PackageReference\s+Include="([^"]+)"/;
+function extractCsproj(text) {
+  const hits = [];
+  let inComment = false;
+  eachLine(text, (rawLine, lineNumber) => {
+    const stripped = stripXmlComments(rawLine, inComment);
+    inComment = stripped.inComment;
+    const name = CSPROJ_PACKAGE_REFERENCE.exec(stripped.visible)?.[1];
+    if (name !== void 0) hits.push(makeHit("nuget", name, lineNumber, rawLine));
+  });
+  return hits;
+}
+var PACKAGES_CONFIG_PACKAGE = /<package\s+id="([^"]+)"/;
+function extractPackagesConfig(text) {
+  const hits = [];
+  let inComment = false;
+  eachLine(text, (rawLine, lineNumber) => {
+    const stripped = stripXmlComments(rawLine, inComment);
+    inComment = stripped.inComment;
+    const name = PACKAGES_CONFIG_PACKAGE.exec(stripped.visible)?.[1];
+    if (name !== void 0) hits.push(makeHit("nuget", name, lineNumber, rawLine));
+  });
+  return hits;
+}
+function stripXmlComments(line, inComment) {
+  let visible = "";
+  let rest = line;
+  let comment = inComment;
+  for (; ; ) {
+    if (comment) {
+      const end = rest.indexOf("-->");
+      if (end === -1) return { visible, inComment: true };
+      rest = rest.slice(end + 3);
+      comment = false;
+      continue;
+    }
+    const start = rest.indexOf("<!--");
+    if (start === -1) return { visible: visible + rest, inComment: false };
+    visible += rest.slice(0, start);
+    rest = rest.slice(start + 4);
+    comment = true;
+  }
+}
+function eachLine(text, fn) {
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i += 1) {
+    fn(lines[i] ?? "", i + 1);
+  }
+}
+function parseJson(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const record2 = parsed;
+  return {
+    dependencies: record2.dependencies,
+    optionalDependencies: record2.optionalDependencies,
+    require: record2.require
+  };
+}
+function objectKeys(value) {
+  if (typeof value !== "object" || value === null) return [];
+  return Object.keys(value);
+}
+function hitAtQuotedKey(ecosystem, pkg, text, sectionKey) {
+  const sectionStart = text.indexOf(`"${sectionKey}"`);
+  const searchFrom = sectionStart === -1 ? 0 : sectionStart;
+  const index = text.indexOf(`"${pkg}"`, searchFrom);
+  if (index === -1) return makeHit(ecosystem, pkg, 1, pkg);
+  return makeHit(ecosystem, pkg, lineNumberAt(text, index), lineContaining(text, index));
+}
+function lineNumberAt(text, index) {
+  let line = 1;
+  for (let i = 0; i < index; i += 1) {
+    if (text[i] === "\n") line += 1;
+  }
+  return line;
+}
+function lineContaining(text, index) {
+  const start = text.lastIndexOf("\n", index) + 1;
+  const end = text.indexOf("\n", index);
+  return text.slice(start, end === -1 ? text.length : end);
+}
+
+// ../packages/detections/src/egress/resolve.ts
+var VERB_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE"]);
+function resolveEgress(files, opts) {
+  const resolved = [];
+  for (const file2 of files) {
+    for (const endpoint of file2.endpoints) {
+      const hit = resolveEndpointHit(file2, endpoint, opts);
+      if (hit !== null) resolved.push(hit);
+    }
+    for (const sdkHit of file2.sdkHits) {
+      const hit = resolveSdkHit(file2, sdkHit);
+      if (hit !== null) resolved.push(hit);
+    }
+  }
+  return dropRefsWithVerbSibling(dedupeExact(resolved));
+}
+function resolveEndpointHit(file2, endpoint, opts) {
+  const resolution = resolveHost(endpoint.host, opts);
+  if (resolution === null) return null;
+  const isProvider = resolution.kind === "provider";
+  return {
+    host: endpoint.host,
+    kind: resolution.kind,
+    name: resolution.name,
+    category: resolution.category,
+    trust: resolution.trust,
+    network: isProvider ? null : { port: endpoint.port, geo: null, ptr: null },
+    method: endpoint.method,
+    transport: endpoint.transport,
+    url: endpoint.url,
+    template: endpoint.template,
+    dataClass: isProvider ? resolution.entry?.defaultDataClasses[0] ?? "none" : "none",
+    site: {
+      file: file2.file,
+      line: endpoint.line,
+      snippet: endpoint.snippet,
+      dynamic: endpoint.template,
+      vendored: file2.vendored
+    }
+  };
+}
+function resolveSdkHit(file2, sdkHit) {
+  const entry = resolveSdk(sdkHit.ecosystem, sdkHit.pkg);
+  if (entry === null) return null;
+  return {
+    host: new URL(entry.apiBase).hostname,
+    kind: "provider",
+    name: entry.name,
+    category: entry.category,
+    trust: "recognized",
+    network: null,
+    method: "SDK",
+    transport: "https",
+    url: entry.apiBase,
+    template: false,
+    dataClass: entry.defaultDataClasses[0] ?? "none",
+    site: {
+      file: file2.file,
+      line: sdkHit.line,
+      snippet: sdkHit.snippet,
+      dynamic: false,
+      vendored: file2.vendored
+    }
+  };
+}
+function dedupeExact(hits) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const hit of hits) {
+    const key = exactKey(hit);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(hit);
+  }
+  return deduped;
+}
+function exactKey(hit) {
+  return JSON.stringify([hit.host, hit.method, hit.url, hit.site.file, hit.site.line]);
+}
+function dropRefsWithVerbSibling(hits) {
+  const verbPairs = /* @__PURE__ */ new Set();
+  for (const hit of hits) {
+    if (VERB_METHODS.has(hit.method)) verbPairs.add(pairKey(hit));
+  }
+  return hits.filter((hit) => hit.method !== "REF" || !verbPairs.has(pairKey(hit)));
+}
+function pairKey(hit) {
+  return JSON.stringify([hit.host, hit.url]);
+}
 
 // ../packages/detections/src/escape-regexp.ts
-function escapeRegExp(value) {
+function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
 // ../packages/detections/src/matchers/limits.ts
 var MAX_MATCHES_PER_RULE = 1e4;
+var MAX_REGEX_INPUT_LENGTH = 2e5;
 
 // ../packages/detections/src/matchers/keyword.ts
 var KeywordMatcher = class {
@@ -772,7 +2174,7 @@ var KeywordMatcher = class {
     for (const kw of keywords) {
       if (kw.length === 0) continue;
       if (spans.length >= MAX_MATCHES_PER_RULE) break;
-      const re = new RegExp(escapeRegExp(kw), caseSensitive ? "gu" : "giu");
+      const re = new RegExp(escapeRegExp2(kw), caseSensitive ? "gu" : "giu");
       let m;
       while ((m = re.exec(text)) !== null) {
         spans.push({ start: m.index, end: m.index + m[0].length });
@@ -789,9 +2191,13 @@ var RegexMatcher = class {
     if (rule.matcher.type !== "regex") return [];
     const { pattern, flags, captureGroup } = rule.matcher;
     const re = new RegExp(pattern, flags.includes("d") ? flags : `${flags}d`);
+    const scanText2 = text.length > MAX_REGEX_INPUT_LENGTH ? text.slice(0, MAX_REGEX_INPUT_LENGTH) : text;
     const spans = [];
     let m;
-    while ((m = re.exec(text)) !== null) {
+    const maxIterations = scanText2.length + 1;
+    let iterations = 0;
+    while ((m = re.exec(scanText2)) !== null) {
+      if (++iterations > maxIterations) break;
       const group = captureGroup != null ? m[captureGroup] : m[0];
       if (m[0].length === 0) re.lastIndex++;
       if (group && spans.length < MAX_MATCHES_PER_RULE) {
@@ -895,7 +2301,7 @@ function isCorroborated(candidate, candidates, text) {
     for (const label of labels) {
       const trimmed = label.trim();
       if (trimmed.length === 0) continue;
-      const re = new RegExp(`(?<![A-Za-z0-9])${escapeRegExp(trimmed)}(?![A-Za-z0-9])`, "i");
+      const re = new RegExp(`(?<![A-Za-z0-9])${escapeRegExp2(trimmed)}(?![A-Za-z0-9])`, "i");
       if (re.test(haystack)) return true;
     }
   }
@@ -1060,6 +2466,37 @@ var CONFIG_POSTURE_RULES = [
   }
 ];
 
+// ../packages/detections/src/security/redos-probe.ts
+var EXPONENTIAL_UNITS = [
+  "a",
+  "0",
+  " ",
+  "x",
+  "ab",
+  "a.",
+  "a-",
+  "a_",
+  "a@",
+  "a/",
+  "a:",
+  "a=",
+  "a;",
+  "aA0",
+  "	"
+];
+var EXPONENTIAL_PROBES = EXPONENTIAL_UNITS.flatMap(
+  (unit) => [23, 25].map((len) => unit.repeat(Math.ceil(len / unit.length)).slice(0, len) + "!")
+);
+var POLYNOMIAL_PROBES = ["abc-", "a.", "a ", "a=", "x", "0", "a@", "a/", "ab"].map(
+  (unit) => unit.repeat(1e4).slice(0, 4e4) + "!"
+);
+
+// ../packages/persistence/src/database.ts
+import { randomUUID as randomUUID8 } from "crypto";
+import { existsSync as existsSync2, renameSync, rmSync } from "fs";
+import { join as join2, sep } from "path";
+import { DatabaseSync } from "node:sqlite";
+
 // ../packages/schema/src/drizzle/sqlite-ddl.ts
 var SQLITE_MIGRATIONS = [
   {
@@ -1105,6 +2542,10 @@ var SQLITE_MIGRATIONS = [
   {
     tag: "0010_events_session_expression_index",
     sql: "-- Custom migration: partial expression index for session-scoped finding reads.\n--\n-- sessionFindingsCount, the session-scoped listGroupedFindings paths, and the\n-- insert-time session dedup all filter live-capture events by\n--   json_extract(e.metadata, '$.sessionId') = :sessionId\n-- \u2014 previously a full findings-join scan with a JSON parse per row. The\n-- IS NOT NULL predicate keeps the index to session-stamped events only (an\n-- equality probe implies non-null, so SQLite still uses it).\nCREATE INDEX `idx_events_session_id` ON `events` (json_extract(`metadata`, '$.sessionId')) WHERE json_extract(`metadata`, '$.sessionId') IS NOT NULL;\n"
+  },
+  {
+    tag: "0011_egress_writer",
+    sql: '-- Stable per-project reconcile key for egress call sites, plus a host-keyed\n-- egress decision override that survives destination pruning.\n--\n-- DROP INDEX IF EXISTS, not a bare DROP: the applier replays a pending\n-- migration\'s non-index statements verbatim, so a store that lost\n-- uq_share_call_site out of band would throw here \u2014 and on the plugin hook path\n-- that throw is swallowed fail-open, silently stopping capture.\n--\n-- Existing rows carry the old key\'s discriminator into project_key\n-- (\'legacy:\' || project), so the new unique index is a re-encoding of the old\n-- one and cannot collide on rows the old one allowed. Leaving them on the\n-- column default would collapse two projects\' identical file/line hits onto\n-- one key and abort the whole migration. Writer keys are \'git:\'/\'path:\'-\n-- prefixed, so a backfilled row never collides with a captured one either.\n--\n-- egress_decision_override.destination_id becomes nullable with ON DELETE SET\n-- NULL, which SQLite can only do by rebuilding the table. `host` is ADDed\n-- before the rebuild so the copy has a column to read and so the migration\n-- still presents two probeable columns to the applier\'s evidence check.\nALTER TABLE `share_call_site` ADD `project_key` text DEFAULT \'\' NOT NULL;--> statement-breakpoint\nUPDATE `share_call_site` SET `project_key` = \'legacy:\' || `project`;--> statement-breakpoint\nDROP INDEX IF EXISTS `uq_share_call_site`;--> statement-breakpoint\nCREATE UNIQUE INDEX `uq_share_call_site` ON `share_call_site` (`endpoint_id`,`project_key`,`file`,`line`);--> statement-breakpoint\nCREATE INDEX `idx_share_call_site_project` ON `share_call_site` (`project_key`,`endpoint_id`);--> statement-breakpoint\nALTER TABLE `egress_decision_override` ADD `host` text;--> statement-breakpoint\nPRAGMA foreign_keys=OFF;--> statement-breakpoint\nCREATE TABLE `__new_egress_decision_override` (\n	`id` text PRIMARY KEY NOT NULL,\n	`destination_id` text,\n	`host` text,\n	`decision` text NOT NULL,\n	`created_at` integer NOT NULL,\n	`updated_at` integer NOT NULL,\n	FOREIGN KEY (`destination_id`) REFERENCES `share_destination`(`id`) ON UPDATE no action ON DELETE set null\n);\n--> statement-breakpoint\nINSERT INTO `__new_egress_decision_override`("id", "destination_id", "host", "decision", "created_at", "updated_at") SELECT "id", "destination_id", "host", "decision", "created_at", "updated_at" FROM `egress_decision_override`;--> statement-breakpoint\nDROP TABLE `egress_decision_override`;--> statement-breakpoint\nALTER TABLE `__new_egress_decision_override` RENAME TO `egress_decision_override`;--> statement-breakpoint\nPRAGMA foreign_keys=ON;--> statement-breakpoint\nCREATE UNIQUE INDEX `uq_egress_decision_override` ON `egress_decision_override` (`destination_id`);--> statement-breakpoint\nCREATE UNIQUE INDEX `uq_egress_decision_override_host` ON `egress_decision_override` (`host`) WHERE `host` IS NOT NULL;\n'
   }
 ];
 
@@ -16883,6 +18324,7 @@ var ExceptionBundleEntry = DetectionException.pick({
 
 // ../packages/schema/src/zod/rule.ts
 var MatcherType = external_exports.enum(["keyword", "regex", "validator"]).meta({ id: "MatcherType" });
+var RuleProbeVerdict = external_exports.enum(["safe", "quarantined"]).meta({ id: "RuleProbeVerdict" });
 var KeywordMatcher2 = external_exports.object({
   type: external_exports.literal("keyword"),
   // An empty keyword matches at every position, yielding one zero-length span
@@ -16907,9 +18349,10 @@ function matchesEmptyString(pattern, flags) {
     return false;
   }
 }
+var MAX_PATTERN_LENGTH = 2e3;
 var RegexMatcher2 = external_exports.object({
   type: external_exports.literal("regex"),
-  pattern: external_exports.string(),
+  pattern: external_exports.string().min(1).max(MAX_PATTERN_LENGTH),
   flags: external_exports.string().default("gi"),
   captureGroup: external_exports.number().int().nonnegative().optional()
 }).refine((v) => isValidRegex(v.pattern, v.flags), {
@@ -17396,85 +18839,291 @@ var ImportDetectionRequest = external_exports.object({
   libraryId: external_exports.string().refine((v) => /^[^/]+\/[^/]+$/.test(v), {
     message: "libraryId must be in namespace/packId format"
   })
-}).meta({ id: "ImportDetectionRequest" });
-
-// ../packages/schema/src/zod/detection-build.ts
-function summaryToDetectionListItem(s) {
-  return {
-    id: `${s.namespace}/${s.packId}`,
-    name: s.name,
-    version: s.version,
-    enabled: s.enabled,
-    origin: "library",
-    // v1: every installed pack is library origin
-    namespace: s.namespace,
-    packId: s.packId,
-    ruleCount: s.ruleCount,
-    ...s.policyId != null ? { policyId: s.policyId } : {},
-    ...s.latestVersion != null ? { latestVersion: s.latestVersion } : {}
-  };
-}
-function rowToDetectionDetail(row, findingsLast30d, update) {
-  const rules = row.rules.flatMap((r) => {
-    const parsed = Matcher.safeParse(r.matcher);
-    if (!parsed.success) return [];
-    return [
-      {
-        id: r.id,
-        name: r.name,
-        category: r.category,
-        severity: r.severity,
-        matcher: parsed.data
-      }
-    ];
-  });
-  return {
-    id: `${row.namespace}/${row.packId}`,
-    name: row.name,
-    version: row.version,
-    enabled: row.enabled,
-    origin: "library",
-    namespace: row.namespace,
-    packId: row.packId,
-    ruleCount: row.rules.length,
-    editedAt: row.updatedAt.toISOString(),
-    findingsLast30d,
-    latestVersion: update ? update.latestVersion : null,
-    update,
-    rules,
-    modified: false,
-    ...row.policyId != null ? { policyId: row.policyId } : {}
-  };
-}
-function splitDetectionId(id) {
-  const idx = id.indexOf("/");
-  if (idx < 1 || idx === id.length - 1) return null;
-  return { namespace: id.slice(0, idx), packId: id.slice(idx + 1) };
-}
-function buildDetectionsList(summaries, query) {
-  const withUpdate = summaries.filter((s) => s.latestVersion != null);
-  const counts = {
-    all: summaries.length,
-    library: summaries.length,
-    // all origin=library in v1
-    custom: 0,
-    customized: 0,
-    updates: withUpdate.length
-  };
-  const filter = query.filter;
-  let filtered = filter === "custom" || filter === "customized" ? [] : filter === "updates" ? [...withUpdate] : [...summaries];
-  if (query.q) {
-    const q = query.q.toLowerCase();
-    filtered = filtered.filter(
-      (s) => s.name.toLowerCase().includes(q) || s.packId.toLowerCase().includes(q) || s.namespace.toLowerCase().includes(q)
-    );
-  }
-  filtered.sort((a, b) => {
-    if (a.enabled !== b.enabled) return a.enabled ? -1 : 1;
-    return a.name.localeCompare(b.name);
-  });
-  return { counts, items: filtered.map(summaryToDetectionListItem) };
-}
+}).meta({ id: "ImportDetectionRequest" });
+
+// ../packages/schema/src/zod/detection-build.ts
+function summaryToDetectionListItem(s) {
+  return {
+    id: `${s.namespace}/${s.packId}`,
+    name: s.name,
+    version: s.version,
+    enabled: s.enabled,
+    origin: "library",
+    // v1: every installed pack is library origin
+    namespace: s.namespace,
+    packId: s.packId,
+    ruleCount: s.ruleCount,
+    ...s.policyId != null ? { policyId: s.policyId } : {},
+    ...s.latestVersion != null ? { latestVersion: s.latestVersion } : {}
+  };
+}
+function rowToDetectionDetail(row, findingsLast30d, update) {
+  const rules = row.rules.flatMap((r) => {
+    const parsed = Matcher.safeParse(r.matcher);
+    if (!parsed.success) return [];
+    return [
+      {
+        id: r.id,
+        name: r.name,
+        category: r.category,
+        severity: r.severity,
+        matcher: parsed.data
+      }
+    ];
+  });
+  return {
+    id: `${row.namespace}/${row.packId}`,
+    name: row.name,
+    version: row.version,
+    enabled: row.enabled,
+    origin: "library",
+    namespace: row.namespace,
+    packId: row.packId,
+    ruleCount: row.rules.length,
+    editedAt: row.updatedAt.toISOString(),
+    findingsLast30d,
+    latestVersion: update ? update.latestVersion : null,
+    update,
+    rules,
+    modified: false,
+    ...row.policyId != null ? { policyId: row.policyId } : {}
+  };
+}
+function splitDetectionId(id) {
+  const idx = id.indexOf("/");
+  if (idx < 1 || idx === id.length - 1) return null;
+  return { namespace: id.slice(0, idx), packId: id.slice(idx + 1) };
+}
+function buildDetectionsList(summaries, query) {
+  const withUpdate = summaries.filter((s) => s.latestVersion != null);
+  const counts = {
+    all: summaries.length,
+    library: summaries.length,
+    // all origin=library in v1
+    custom: 0,
+    customized: 0,
+    updates: withUpdate.length
+  };
+  const filter = query.filter;
+  let filtered = filter === "custom" || filter === "customized" ? [] : filter === "updates" ? [...withUpdate] : [...summaries];
+  if (query.q) {
+    const q = query.q.toLowerCase();
+    filtered = filtered.filter(
+      (s) => s.name.toLowerCase().includes(q) || s.packId.toLowerCase().includes(q) || s.namespace.toLowerCase().includes(q)
+    );
+  }
+  filtered.sort((a, b) => {
+    if (a.enabled !== b.enabled) return a.enabled ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+  return { counts, items: filtered.map(summaryToDetectionListItem) };
+}
+
+// ../packages/schema/src/zod/shares.ts
+var DestinationKind = external_exports.enum(["provider", "internal", "external", "ip"]).meta({ id: "DestinationKind" });
+var Transport = external_exports.enum(["https", "http", "sftp", "grpc", "smtp", "ws", "wss"]).meta({ id: "Transport" });
+var DataClass = external_exports.enum(["secrets", "pii", "customer", "source", "telemetry", "logs", "metrics", "none"]).meta({ id: "DataClass" });
+var DATA_CLASS_ORDER = DataClass.options;
+var ShareTrustLevel = external_exports.enum(["recognized", "internal", "unverified", "ip"]).meta({ id: "ShareTrustLevel" });
+var EgressDecision = external_exports.enum(["allow", "block"]).meta({ id: "EgressDecision" });
+var EgressStatus = external_exports.enum(["allowed", "blocked", "review"]).meta({ id: "EgressStatus" });
+var ReviewReason = external_exports.enum(["raw_ip", "unverified_domain", "plaintext_transport"]).meta({ id: "ReviewReason" });
+var HttpMethod = external_exports.enum(["GET", "POST", "PUT", "DELETE", "SDK", "REF"]).meta({ id: "HttpMethod" });
+var ReviewInfo = external_exports.object({
+  needsReview: external_exports.boolean(),
+  reasons: external_exports.array(ReviewReason)
+}).meta({ id: "ReviewInfo" });
+var DestinationNetwork = external_exports.object({
+  port: external_exports.number().int().nullable(),
+  geo: external_exports.string().nullable(),
+  ptr: external_exports.string().nullable()
+}).meta({ id: "DestinationNetwork" });
+var EndpointSummary = external_exports.object({
+  id: external_exports.string(),
+  method: HttpMethod,
+  transport: Transport,
+  url: external_exports.string(),
+  template: external_exports.boolean(),
+  dataClass: DataClass,
+  lastSeen: external_exports.iso.datetime(),
+  callSiteCount: external_exports.number().int().nonnegative()
+}).meta({ id: "EndpointSummary" });
+var CallSite = external_exports.object({
+  id: external_exports.string(),
+  project: external_exports.string(),
+  file: external_exports.string(),
+  line: external_exports.number().int().nonnegative(),
+  snippet: external_exports.string(),
+  dynamic: external_exports.boolean(),
+  vendored: external_exports.boolean(),
+  /** Deep-link to the Inventory project, when the repo is governed there. */
+  projectId: external_exports.string().nullable()
+}).meta({ id: "CallSite" });
+var EndpointWithSites = EndpointSummary.extend({
+  sites: external_exports.array(CallSite)
+}).meta({ id: "EndpointWithSites" });
+var ShareDestinationSummary = external_exports.object({
+  id: external_exports.string(),
+  kind: DestinationKind,
+  name: external_exports.string(),
+  host: external_exports.string(),
+  category: external_exports.string(),
+  trust: ShareTrustLevel,
+  /** Effective state (decision applied over the trust default). */
+  status: EgressStatus,
+  /** True when an egress decision override differs from the trust default. */
+  isCustom: external_exports.boolean(),
+  lastSeen: external_exports.iso.datetime(),
+  endpointCount: external_exports.number().int().nonnegative(),
+  callSiteCount: external_exports.number().int().nonnegative(),
+  transports: external_exports.array(Transport),
+  /** Most-sensitive first. */
+  dataClasses: external_exports.array(DataClass),
+  review: ReviewInfo,
+  /** Non-provider hosts only; null for providers. */
+  network: DestinationNetwork.nullable(),
+  /** Embedded for inline expansion — no call sites here. */
+  endpoints: external_exports.array(EndpointSummary)
+}).meta({ id: "ShareDestinationSummary" });
+var ShareDestinationDetail = ShareDestinationSummary.omit({
+  endpointCount: true,
+  callSiteCount: true,
+  endpoints: true
+}).extend({
+  /** Ownership/geo rationale; null for providers. */
+  note: external_exports.string().nullable(),
+  endpoints: external_exports.array(EndpointWithSites)
+}).meta({ id: "ShareDestinationDetail" });
+var ReviewDestination = external_exports.object({
+  id: external_exports.string(),
+  kind: DestinationKind,
+  name: external_exports.string(),
+  /** Registrable host — lets the strip derive the provider lettermark, as the register does. */
+  host: external_exports.string(),
+  trust: ShareTrustLevel,
+  status: EgressStatus,
+  review: ReviewInfo,
+  topDataClass: DataClass,
+  callSiteCount: external_exports.number().int().nonnegative(),
+  lastSeen: external_exports.iso.datetime()
+}).meta({ id: "ReviewDestination" });
+var ShareDestinationGroup = external_exports.object({
+  kind: DestinationKind,
+  total: external_exports.number().int().nonnegative(),
+  items: external_exports.array(ShareDestinationSummary)
+}).meta({ id: "ShareDestinationGroup" });
+var ListShareDestinationsResponse = external_exports.object({ groups: external_exports.array(ShareDestinationGroup) }).meta({ id: "ListShareDestinationsResponse" });
+var NeedsReviewResponse = external_exports.object({ items: external_exports.array(ReviewDestination) }).meta({ id: "NeedsReviewResponse" });
+var SharesStats = external_exports.object({
+  destinations: external_exports.number().int().nonnegative(),
+  endpoints: external_exports.number().int().nonnegative(),
+  callSites: external_exports.number().int().nonnegative(),
+  needsReview: external_exports.number().int().nonnegative(),
+  insecure: external_exports.number().int().nonnegative(),
+  byKind: external_exports.object({
+    provider: external_exports.number().int().nonnegative(),
+    internal: external_exports.number().int().nonnegative(),
+    external: external_exports.number().int().nonnegative(),
+    ip: external_exports.number().int().nonnegative()
+  }),
+  byTrust: external_exports.object({
+    recognized: external_exports.number().int().nonnegative(),
+    internal: external_exports.number().int().nonnegative(),
+    unverified: external_exports.number().int().nonnegative(),
+    ip: external_exports.number().int().nonnegative()
+  })
+}).meta({ id: "SharesStats" });
+var SetEgressDecisionBody = external_exports.object({
+  /** `null` clears the override — reverts to the trust default, isCustom false. */
+  decision: EgressDecision.nullable()
+}).meta({ id: "SetEgressDecisionBody" });
+var SetEgressDecisionResponse = external_exports.object({ destination: ShareDestinationSummary }).meta({ id: "SetEgressDecisionResponse" });
+var ListShareDestinationsQuery = external_exports.object({
+  /** Case-insensitive match over destination name/category, endpoint url, call-site project/file. */
+  q: external_exports.string().optional(),
+  /** Repeatable. Restrict to these DestinationKind values; absent means all kinds. */
+  kind: external_exports.array(DestinationKind).optional(),
+  /** Reserved for future grouping modes; only 'destination' is supported today. */
+  groupBy: external_exports.enum(["destination"]).default("destination"),
+  /**
+   * When true, return a flat severity-ordered `items[]` instead of `groups`.
+   * Uses `z.stringbool()` (NOT `z.coerce.boolean()` — `Boolean(str)` is true for
+   * any non-empty string, so `?review=false`/`?review=0` would wrongly coerce
+   * to `true`). `z.stringbool()` parses true/1/yes vs false/0/no correctly.
+   */
+  review: external_exports.stringbool().default(false)
+});
+var ExportSharesQuery = external_exports.object({
+  format: external_exports.enum(["csv", "json"]).default("csv"),
+  q: external_exports.string().optional(),
+  kind: external_exports.array(DestinationKind).optional()
+});
+
+// ../packages/schema/src/zod/egress-extraction.ts
+var EgressEcosystem = external_exports.enum(["npm", "pypi", "go", "maven", "rubygems", "cargo", "composer", "nuget"]).meta({ id: "EgressEcosystem" });
+var ProviderRegistryEntry = external_exports.object({
+  id: external_exports.string(),
+  name: external_exports.string(),
+  category: external_exports.string(),
+  /** Suffix-matched: 'stripe.com' matches api.stripe.com, never evilstripe.com. */
+  hostSuffixes: external_exports.array(external_exports.string()).min(1),
+  /** Canonical API base URL recorded for manifest-derived (method 'SDK') endpoints. */
+  apiBase: external_exports.string(),
+  /** Most-sensitive first; index 0 becomes the endpoint dataClass. */
+  defaultDataClasses: external_exports.array(DataClass).min(1),
+  /** SDK identifiers per ecosystem ('go' prefix-matched by path, 'maven' by group-id prefix). */
+  sdks: external_exports.partialRecord(EgressEcosystem, external_exports.array(external_exports.string()))
+}).meta({ id: "ProviderRegistryEntry" });
+var EgressCallSiteHit = external_exports.object({
+  file: external_exports.string(),
+  line: external_exports.number().int().positive(),
+  snippet: external_exports.string(),
+  dynamic: external_exports.boolean(),
+  vendored: external_exports.boolean()
+}).meta({ id: "EgressCallSiteHit" });
+var ResolvedEgressHit = external_exports.object({
+  host: external_exports.string(),
+  kind: DestinationKind,
+  name: external_exports.string(),
+  category: external_exports.string(),
+  trust: ShareTrustLevel,
+  network: DestinationNetwork.nullable(),
+  method: HttpMethod,
+  transport: Transport,
+  url: external_exports.string(),
+  template: external_exports.boolean(),
+  dataClass: DataClass,
+  site: EgressCallSiteHit
+}).meta({ id: "ResolvedEgressHit" });
+var EgressReconcile = external_exports.discriminatedUnion("mode", [
+  external_exports.object({ mode: external_exports.literal("walk"), walkedPrefix: external_exports.string() }),
+  external_exports.object({
+    mode: external_exports.literal("ledger"),
+    scannedFiles: external_exports.array(external_exports.string()),
+    deletedFiles: external_exports.array(external_exports.string())
+  })
+]).meta({ id: "EgressReconcile" });
+var RecordProjectEgressInput = external_exports.object({
+  /** Stable reconcile key: 'git:<repo identity>' or 'path:<abs root>' (non-git). */
+  projectKey: external_exports.string().min(1),
+  /** Display name only — never keys reconciliation. */
+  project: external_exports.string(),
+  projectId: external_exports.string().nullable(),
+  reconcile: EgressReconcile,
+  hits: external_exports.array(ResolvedEgressHit)
+}).meta({ id: "RecordProjectEgressInput" });
+var EgressWriteSummary = external_exports.object({
+  destinations: external_exports.number().int().nonnegative(),
+  endpoints: external_exports.number().int().nonnegative(),
+  callSites: external_exports.number().int().nonnegative(),
+  truncated: external_exports.boolean(),
+  /**
+   * Files the cap dropped whole. Their stored rows were left untouched, so a
+   * ledger-keeping caller must withhold their ledger entries and read them
+   * again next scan.
+   */
+  droppedFiles: external_exports.array(external_exports.string()).default([])
+}).meta({ id: "EgressWriteSummary" });
 
 // ../packages/schema/src/zod/findings-group-build.ts
 function toApiAction(dbVal) {
@@ -17737,7 +19386,7 @@ var PatchInstalledPackRequest = external_exports.object({
 }).meta({ id: "PatchInstalledPackRequest" });
 
 // ../packages/schema/src/zod/local.ts
-var WORKSPACE_SETTINGS_SPEC_VERSION = 2;
+var WORKSPACE_SETTINGS_SPEC_VERSION = 3;
 var RunMode = external_exports.enum(["standalone"]);
 var SimpleDetectionPolicy = external_exports.enum(["redact", "warn"]);
 var HistoricalAccess = external_exports.enum(["full", "session-only"]);
@@ -17752,6 +19401,9 @@ var WorkspaceSettings = external_exports.object({
   policy: SimpleDetectionPolicy.default("redact"),
   // Consent for scanning pre-install surfaces; opt-in (see HistoricalAccess).
   historicalAccess: HistoricalAccess.default("session-only"),
+  // In-place egress extraction on the scan paths; disable to stop all Data
+  // Shares writes.
+  dataSharesInPlace: external_exports.boolean().default(true),
   // Absent until /aka:setup completes; its presence is what "onboarded" means.
   onboardedAt: external_exports.iso.datetime().optional()
 });
@@ -18161,220 +19813,81 @@ var TriageRecommendation = external_exports.object({
 });
 
 // ../packages/schema/src/zod/setup-frame.ts
-var CalibrationCounts = external_exports.object({
-  total: external_exports.number().int().nonnegative(),
-  important: external_exports.number().int().nonnegative(),
-  routine: external_exports.number().int().nonnegative()
-}).refine((c) => c.total === c.important + c.routine, {
-  message: "total must equal important + routine",
-  path: ["total"]
-});
-var FalsePositivePatternValue = external_exports.object({
-  ruleId: external_exports.string(),
-  category: DetectionCategory,
-  valueFingerprint: external_exports.string(),
-  keyVersion: external_exports.number().int().nonnegative()
-});
-var FalsePositivePatternGroup = external_exports.object({
-  pattern: external_exports.string(),
-  count: external_exports.number().int().nonnegative(),
-  values: external_exports.array(FalsePositivePatternValue).min(1)
-});
-var CalibrationFindingKind = external_exports.object({
-  category: DetectionCategory,
-  count: external_exports.number().int().nonnegative(),
-  egress: external_exports.boolean()
-});
-var CalibrationFrame = external_exports.object({
-  counts: CalibrationCounts,
-  routineCategories: external_exports.array(DetectionCategory),
-  surfacedCategories: external_exports.array(DetectionCategory),
-  findingKinds: external_exports.array(CalibrationFindingKind),
-  posture: external_exports.record(DetectionCategory, BuiltinPolicyId),
-  maskedFindings: external_exports.array(MaskedSecretFinding).optional(),
-  falsePositivePatterns: external_exports.array(FalsePositivePatternGroup).optional()
-});
-var CalibrationPreviewCategory = TriageCategoryRec.pick({
-  category: true,
-  genuineCount: true,
-  fpCount: true
-}).extend({
-  egress: external_exports.boolean()
-});
-var CalibrationPreview = external_exports.object({
-  categories: external_exports.array(CalibrationPreviewCategory),
-  posture: external_exports.record(DetectionCategory, BuiltinPolicyId)
-});
-var CalibrationResult = external_exports.object({
-  frame: CalibrationFrame,
-  copy: external_exports.string()
-});
-var FirstRunCalibration = external_exports.enum(["scan", "floor"]);
-var SetupHandoffOption = external_exports.object({
-  id: external_exports.enum(["enter-remediation", "open-dashboard", "not-now"]),
-  label: external_exports.string()
-});
-var DashboardHandoffOptions = external_exports.tuple([
-  SetupHandoffOption.extend({ id: external_exports.literal("open-dashboard") }),
-  SetupHandoffOption.extend({ id: external_exports.literal("not-now") })
-]);
-var ComposedRemediationOptions = external_exports.tuple([
-  SetupHandoffOption.extend({ id: external_exports.literal("enter-remediation") }),
-  SetupHandoffOption.extend({ id: external_exports.literal("open-dashboard") }),
-  SetupHandoffOption.extend({ id: external_exports.literal("not-now") })
-]);
-var SetupHandoffOffer = external_exports.object({
-  worthALook: external_exports.number().int().nonnegative(),
-  liveKeys: external_exports.number().int().nonnegative().optional(),
-  options: external_exports.union([DashboardHandoffOptions, ComposedRemediationOptions])
-}).refine(
-  (o) => o.options.some((opt) => opt.id === "enter-remediation") === (o.liveKeys ?? 0) > 0,
-  {
-    message: "the chain-entry option is present exactly when liveKeys > 0",
-    path: ["options"]
-  }
-).refine((o) => (o.liveKeys ?? 0) <= o.worthALook, {
-  message: "liveKeys is a subset of worthALook and cannot exceed it",
-  path: ["liveKeys"]
-});
-
-// ../packages/schema/src/zod/shares.ts
-var DestinationKind = external_exports.enum(["provider", "internal", "ip"]).meta({ id: "DestinationKind" });
-var Transport = external_exports.enum(["https", "http", "sftp", "grpc", "smtp"]).meta({ id: "Transport" });
-var DataClass = external_exports.enum(["secrets", "pii", "customer", "source", "telemetry", "logs", "metrics", "none"]).meta({ id: "DataClass" });
-var DATA_CLASS_ORDER = DataClass.options;
-var ShareTrustLevel = external_exports.enum(["recognized", "internal", "unverified", "ip"]).meta({ id: "ShareTrustLevel" });
-var EgressDecision = external_exports.enum(["allow", "block"]).meta({ id: "EgressDecision" });
-var EgressStatus = external_exports.enum(["allowed", "blocked", "review"]).meta({ id: "EgressStatus" });
-var ReviewReason = external_exports.enum(["raw_ip", "unverified_domain", "plaintext_transport"]).meta({ id: "ReviewReason" });
-var HttpMethod = external_exports.enum(["GET", "POST", "PUT", "DELETE"]).meta({ id: "HttpMethod" });
-var ReviewInfo = external_exports.object({
-  needsReview: external_exports.boolean(),
-  reasons: external_exports.array(ReviewReason)
-}).meta({ id: "ReviewInfo" });
-var DestinationNetwork = external_exports.object({
-  port: external_exports.number().int().nullable(),
-  geo: external_exports.string().nullable(),
-  ptr: external_exports.string().nullable()
-}).meta({ id: "DestinationNetwork" });
-var EndpointSummary = external_exports.object({
-  id: external_exports.string(),
-  method: HttpMethod,
-  transport: Transport,
-  url: external_exports.string(),
-  template: external_exports.boolean(),
-  dataClass: DataClass,
-  lastSeen: external_exports.iso.datetime(),
-  callSiteCount: external_exports.number().int().nonnegative()
-}).meta({ id: "EndpointSummary" });
-var CallSite = external_exports.object({
-  id: external_exports.string(),
-  project: external_exports.string(),
-  file: external_exports.string(),
-  line: external_exports.number().int().nonnegative(),
-  snippet: external_exports.string(),
-  dynamic: external_exports.boolean(),
-  vendored: external_exports.boolean(),
-  /** Deep-link to the Inventory project, when the repo is governed there. */
-  projectId: external_exports.string().nullable()
-}).meta({ id: "CallSite" });
-var EndpointWithSites = EndpointSummary.extend({
-  sites: external_exports.array(CallSite)
-}).meta({ id: "EndpointWithSites" });
-var ShareDestinationSummary = external_exports.object({
-  id: external_exports.string(),
-  kind: DestinationKind,
-  name: external_exports.string(),
-  host: external_exports.string(),
-  category: external_exports.string(),
-  trust: ShareTrustLevel,
-  /** Effective state (decision applied over the trust default). */
-  status: EgressStatus,
-  /** True when an egress decision override differs from the trust default. */
-  isCustom: external_exports.boolean(),
-  lastSeen: external_exports.iso.datetime(),
-  endpointCount: external_exports.number().int().nonnegative(),
-  callSiteCount: external_exports.number().int().nonnegative(),
-  transports: external_exports.array(Transport),
-  /** Most-sensitive first. */
-  dataClasses: external_exports.array(DataClass),
-  review: ReviewInfo,
-  /** Non-provider hosts only; null for providers. */
-  network: DestinationNetwork.nullable(),
-  /** Embedded for inline expansion — no call sites here. */
-  endpoints: external_exports.array(EndpointSummary)
-}).meta({ id: "ShareDestinationSummary" });
-var ShareDestinationDetail = ShareDestinationSummary.omit({
-  endpointCount: true,
-  callSiteCount: true,
-  endpoints: true
-}).extend({
-  /** Ownership/geo rationale; null for providers. */
-  note: external_exports.string().nullable(),
-  endpoints: external_exports.array(EndpointWithSites)
-}).meta({ id: "ShareDestinationDetail" });
-var ReviewDestination = external_exports.object({
-  id: external_exports.string(),
-  kind: DestinationKind,
-  name: external_exports.string(),
-  /** Registrable host — lets the strip derive the provider lettermark, as the register does. */
-  host: external_exports.string(),
-  trust: ShareTrustLevel,
-  status: EgressStatus,
-  review: ReviewInfo,
-  topDataClass: DataClass,
-  callSiteCount: external_exports.number().int().nonnegative(),
-  lastSeen: external_exports.iso.datetime()
-}).meta({ id: "ReviewDestination" });
-var ShareDestinationGroup = external_exports.object({
-  kind: DestinationKind,
+var CalibrationCounts = external_exports.object({
   total: external_exports.number().int().nonnegative(),
-  items: external_exports.array(ShareDestinationSummary)
-}).meta({ id: "ShareDestinationGroup" });
-var ListShareDestinationsResponse = external_exports.object({ groups: external_exports.array(ShareDestinationGroup) }).meta({ id: "ListShareDestinationsResponse" });
-var NeedsReviewResponse = external_exports.object({ items: external_exports.array(ReviewDestination) }).meta({ id: "NeedsReviewResponse" });
-var SharesStats = external_exports.object({
-  destinations: external_exports.number().int().nonnegative(),
-  endpoints: external_exports.number().int().nonnegative(),
-  callSites: external_exports.number().int().nonnegative(),
-  needsReview: external_exports.number().int().nonnegative(),
-  insecure: external_exports.number().int().nonnegative(),
-  byKind: external_exports.object({
-    provider: external_exports.number().int().nonnegative(),
-    internal: external_exports.number().int().nonnegative(),
-    ip: external_exports.number().int().nonnegative()
-  }),
-  byTrust: external_exports.object({
-    recognized: external_exports.number().int().nonnegative(),
-    internal: external_exports.number().int().nonnegative(),
-    unverified: external_exports.number().int().nonnegative(),
-    ip: external_exports.number().int().nonnegative()
-  })
-}).meta({ id: "SharesStats" });
-var SetEgressDecisionBody = external_exports.object({
-  /** `null` clears the override — reverts to the trust default, isCustom false. */
-  decision: EgressDecision.nullable()
-}).meta({ id: "SetEgressDecisionBody" });
-var SetEgressDecisionResponse = external_exports.object({ destination: ShareDestinationSummary }).meta({ id: "SetEgressDecisionResponse" });
-var ListShareDestinationsQuery = external_exports.object({
-  /** Case-insensitive match over destination name/category, endpoint url, call-site project/file. */
-  q: external_exports.string().optional(),
-  /** Repeatable. Restrict to these DestinationKind values; absent means all kinds. */
-  kind: external_exports.array(DestinationKind).optional(),
-  /** Reserved for future grouping modes; only 'destination' is supported today. */
-  groupBy: external_exports.enum(["destination"]).default("destination"),
-  /**
-   * When true, return a flat severity-ordered `items[]` instead of `groups`.
-   * Uses `z.stringbool()` (NOT `z.coerce.boolean()` — `Boolean(str)` is true for
-   * any non-empty string, so `?review=false`/`?review=0` would wrongly coerce
-   * to `true`). `z.stringbool()` parses true/1/yes vs false/0/no correctly.
-   */
-  review: external_exports.stringbool().default(false)
+  important: external_exports.number().int().nonnegative(),
+  routine: external_exports.number().int().nonnegative()
+}).refine((c) => c.total === c.important + c.routine, {
+  message: "total must equal important + routine",
+  path: ["total"]
 });
-var ExportSharesQuery = external_exports.object({
-  format: external_exports.enum(["csv", "json"]).default("csv"),
-  q: external_exports.string().optional(),
-  kind: external_exports.array(DestinationKind).optional()
+var FalsePositivePatternValue = external_exports.object({
+  ruleId: external_exports.string(),
+  category: DetectionCategory,
+  valueFingerprint: external_exports.string(),
+  keyVersion: external_exports.number().int().nonnegative()
+});
+var FalsePositivePatternGroup = external_exports.object({
+  pattern: external_exports.string(),
+  count: external_exports.number().int().nonnegative(),
+  values: external_exports.array(FalsePositivePatternValue).min(1)
+});
+var CalibrationFindingKind = external_exports.object({
+  category: DetectionCategory,
+  count: external_exports.number().int().nonnegative(),
+  egress: external_exports.boolean()
+});
+var CalibrationFrame = external_exports.object({
+  counts: CalibrationCounts,
+  routineCategories: external_exports.array(DetectionCategory),
+  surfacedCategories: external_exports.array(DetectionCategory),
+  findingKinds: external_exports.array(CalibrationFindingKind),
+  posture: external_exports.record(DetectionCategory, BuiltinPolicyId),
+  maskedFindings: external_exports.array(MaskedSecretFinding).optional(),
+  falsePositivePatterns: external_exports.array(FalsePositivePatternGroup).optional()
+});
+var CalibrationPreviewCategory = TriageCategoryRec.pick({
+  category: true,
+  genuineCount: true,
+  fpCount: true
+}).extend({
+  egress: external_exports.boolean()
+});
+var CalibrationPreview = external_exports.object({
+  categories: external_exports.array(CalibrationPreviewCategory),
+  posture: external_exports.record(DetectionCategory, BuiltinPolicyId)
+});
+var CalibrationResult = external_exports.object({
+  frame: CalibrationFrame,
+  copy: external_exports.string()
+});
+var FirstRunCalibration = external_exports.enum(["scan", "floor"]);
+var SetupHandoffOption = external_exports.object({
+  id: external_exports.enum(["enter-remediation", "open-dashboard", "not-now"]),
+  label: external_exports.string()
+});
+var DashboardHandoffOptions = external_exports.tuple([
+  SetupHandoffOption.extend({ id: external_exports.literal("open-dashboard") }),
+  SetupHandoffOption.extend({ id: external_exports.literal("not-now") })
+]);
+var ComposedRemediationOptions = external_exports.tuple([
+  SetupHandoffOption.extend({ id: external_exports.literal("enter-remediation") }),
+  SetupHandoffOption.extend({ id: external_exports.literal("open-dashboard") }),
+  SetupHandoffOption.extend({ id: external_exports.literal("not-now") })
+]);
+var SetupHandoffOffer = external_exports.object({
+  worthALook: external_exports.number().int().nonnegative(),
+  liveKeys: external_exports.number().int().nonnegative().optional(),
+  options: external_exports.union([DashboardHandoffOptions, ComposedRemediationOptions])
+}).refine(
+  (o) => o.options.some((opt) => opt.id === "enter-remediation") === (o.liveKeys ?? 0) > 0,
+  {
+    message: "the chain-entry option is present exactly when liveKeys > 0",
+    path: ["options"]
+  }
+).refine((o) => (o.liveKeys ?? 0) <= o.worthALook, {
+  message: "liveKeys is a subset of worthALook and cannot exceed it",
+  path: ["liveKeys"]
 });
 
 // ../packages/schema/src/zod/shares-access.ts
@@ -18396,7 +19909,7 @@ function deriveReviewReasons(trust, transports) {
   const reasons = [];
   if (trust === "ip") reasons.push("raw_ip");
   if (trust === "unverified") reasons.push("unverified_domain");
-  if (transports.includes("http")) reasons.push("plaintext_transport");
+  if (transports.includes("http") || transports.includes("ws")) reasons.push("plaintext_transport");
   return reasons;
 }
 function buildReviewInfo(trust, transports) {
@@ -18423,139 +19936,6 @@ function reviewSeverityRank(reasons) {
   return Math.min(...reasons.map((r) => REVIEW_SEVERITY_RANK[r]));
 }
 
-// ../packages/local-ops/src/fs-scan.ts
-var import_ignore = __toESM(require_ignore(), 1);
-var AKAIGNORE_FILENAME = ".akaignore";
-var SKIP_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  "dist",
-  ".next",
-  "coverage",
-  ".turbo",
-  "build",
-  "out"
-]);
-var MAX_BYTES = 1e6;
-function readIgnoreLayer(dir, filename) {
-  try {
-    const content = readFileSync2(join2(dir, filename), "utf8");
-    return { base: dir, matcher: (0, import_ignore.default)().add(content) };
-  } catch {
-    return void 0;
-  }
-}
-function evaluate(layers, absPath, isDir) {
-  let state = "unmatched";
-  for (const layer of layers) {
-    const rel = relative(layer.base, absPath).split(sep).join("/") + (isDir ? "/" : "");
-    const verdict = layer.matcher.test(rel);
-    if (verdict.ignored) state = "ignored";
-    else if (verdict.unignored) state = "unignored";
-  }
-  return state;
-}
-function* collectFiles(target) {
-  let st;
-  try {
-    st = statSync(target);
-  } catch {
-    return;
-  }
-  if (st.isFile()) {
-    if (st.size <= MAX_BYTES) yield { path: target, gitignored: false };
-    return;
-  }
-  if (!st.isDirectory()) return;
-  yield* visit(target, [], [], false);
-}
-function* visit(dir, markLayers, skipLayers, inIgnoredDir) {
-  const markLayer = inIgnoredDir ? void 0 : readIgnoreLayer(dir, ".gitignore");
-  const dirMarkLayers = markLayer ? [...markLayers, markLayer] : markLayers;
-  const skipLayer = readIgnoreLayer(dir, AKAIGNORE_FILENAME);
-  const dirSkipLayers = skipLayer ? [...skipLayers, skipLayer] : skipLayers;
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const path = join2(dir, entry.name);
-    if (entry.isDirectory()) {
-      const skipState = evaluate(dirSkipLayers, path, true);
-      if (skipState !== "unignored" && (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".") || skipState === "ignored")) {
-        continue;
-      }
-      const dirIgnored = inIgnoredDir || evaluate(dirMarkLayers, path, true) === "ignored";
-      yield* visit(path, dirMarkLayers, dirSkipLayers, dirIgnored);
-    } else if (entry.isFile()) {
-      if (evaluate(dirSkipLayers, path, false) === "ignored") continue;
-      let size;
-      try {
-        size = statSync(path).size;
-      } catch {
-        continue;
-      }
-      if (size > MAX_BYTES) continue;
-      yield {
-        path,
-        gitignored: inIgnoredDir || evaluate(dirMarkLayers, path, false) === "ignored"
-      };
-    }
-  }
-}
-function scanPathIntoStore(db, target, opts = {}) {
-  let scanned = 0;
-  let findingCount = 0;
-  const files = [];
-  for (const { path: file2, gitignored } of collectFiles(target)) {
-    let text;
-    try {
-      text = readFileSync2(file2, "utf8");
-    } catch {
-      continue;
-    }
-    scanned++;
-    const matches = scan(text, opts.rules);
-    if (matches.length === 0) continue;
-    const eventId = randomUUID();
-    const metadata = { filePath: file2 };
-    if (gitignored) metadata.gitignored = true;
-    const event = {
-      id: eventId,
-      sourceTool: opts.sourceTool ?? "cli",
-      kind: "code_change",
-      occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
-      contentHash: createHash("sha256").update(text).digest("hex"),
-      content: redact(text, matches),
-      // store the REDACTED file, never the raw secret
-      metadata
-    };
-    const findings = matches.map((m) => ({
-      id: randomUUID(),
-      eventId,
-      ruleId: m.ruleId,
-      category: m.category,
-      severity: m.severity,
-      span: m.span,
-      maskedMatch: maskMatch(m.rawMatch),
-      // Per-pack action (monitor-by-default) when the installed snapshot supplies
-      // one, else the per-category fallback — mirrors the live path's resolveAction.
-      actionTaken: opts.ruleActions?.get(m.ruleId) ?? DEFAULT_ACTIONS[m.category],
-      confidence: m.confidence
-    }));
-    db.recordCapture(event, findings);
-    files.push({ path: file2, gitignored, findings });
-    findingCount += findings.length;
-  }
-  return { scanned, findings: findingCount, files };
-}
-
-// ../packages/local-ops/src/project-inventory.ts
-import { statSync as statSync5 } from "fs";
-import { resolve } from "path";
-
-// ../packages/persistence/src/database.ts
-import { randomUUID as randomUUID9 } from "crypto";
-import { existsSync as existsSync2, renameSync, rmSync } from "fs";
-import { join as join3, sep as sep2 } from "path";
-import { DatabaseSync } from "node:sqlite";
-
 // ../packages/persistence/src/internal/sql-text.ts
 function escapeLikePattern(s) {
   return s.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
@@ -18653,9 +20033,9 @@ function evidenceExists(db, object2) {
 }
 
 // ../packages/persistence/src/ids.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash } from "crypto";
 function sha256Hex(input) {
-  return createHash2("sha256").update(input).digest("hex");
+  return createHash("sha256").update(input).digest("hex");
 }
 function inventoryId(objectType, identityKey) {
   return sha256Hex(canonicalIdentity(["inventory", objectType, identityKey]));
@@ -18749,6 +20129,7 @@ function applyMigrations(db) {
   ensureSyncedAtColumn(db, "audit_events");
   ensureScanLedgerTable(db);
   ensureBlockedDetectionsTable(db);
+  ensureRuleProbeCacheTable(db);
   ensureWriteGateTrigger(db);
   ensureTokenUsageColumns(db);
   reconcileSourceProjectIds(db);
@@ -18888,6 +20269,14 @@ function ensureBlockedDetectionsTable(db) {
     blocked_at INTEGER NOT NULL
   )`);
 }
+function ensureRuleProbeCacheTable(db) {
+  db.exec(`CREATE TABLE IF NOT EXISTS rule_probe_cache (
+    rule_key TEXT PRIMARY KEY,
+    verdict TEXT NOT NULL,
+    worst_probe_ms REAL NOT NULL,
+    checked_at INTEGER NOT NULL
+  )`);
+}
 
 // ../packages/persistence/src/paths.ts
 import { chmodSync, mkdirSync } from "fs";
@@ -20109,7 +21498,7 @@ var SqliteEventsRepository = class {
 };
 
 // ../packages/persistence/src/repositories/exceptions.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID } from "crypto";
 
 // ../packages/persistence/src/internal/sqlite-errors.ts
 var SQLITE_CONSTRAINT_UNIQUE = 2067;
@@ -20187,7 +21576,7 @@ var SqliteExceptionsRepository = class {
         "provider conditions are not supported yet \u2014 a grant with one would never apply"
       );
     }
-    const id = randomUUID2();
+    const id = randomUUID();
     const now = Date.now();
     try {
       this.insertExceptionRow(id, input, now);
@@ -20892,7 +22281,7 @@ var SqliteInspectionFindingsRepository = class {
 };
 
 // ../packages/persistence/src/repositories/installed-packs.ts
-import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
 
 // ../packages/persistence/src/semver.ts
 function parse4(version2) {
@@ -20942,7 +22331,7 @@ function inventorySignature(packs2) {
   return packs2.map((p) => `${p.namespace}/${p.packId}@${p.version}#${hashRules(p.rulesJson)}`).sort().join(",");
 }
 function hashRules(rulesJson) {
-  return createHash3("sha1").update(rulesJson).digest("hex");
+  return createHash2("sha1").update(rulesJson).digest("hex");
 }
 function parseVersion(v) {
   const m = /^(\d+)\.(\d+)\.(\d+)/.exec(v);
@@ -21043,7 +22432,7 @@ var SqliteInstalledPacksRepository = class {
           let behind = false;
           for (const row of rows) {
             const params = {
-              id: randomUUID3(),
+              id: randomUUID2(),
               namespace: row.namespace,
               packId: row.packId,
               version: row.version,
@@ -21055,7 +22444,7 @@ var SqliteInstalledPacksRepository = class {
             if (stored === void 0 || !isMirrorDowngrade(row, stored)) {
               this.upsertAvailableStmt.run({
                 ...params,
-                id: randomUUID3(),
+                id: randomUUID2(),
                 recordedBy: meta3?.recordedBy ?? null
               });
             } else {
@@ -21376,7 +22765,7 @@ var SqliteInventoryRepository = class {
 };
 
 // ../packages/persistence/src/repositories/inventory-assets.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 var CATEGORY_ORDER = ["config", "skill", "mcp", "hook"];
 var VALID_HARNESS_IDS = new Set(HarnessId.options);
 var WORKTREE_CHECKOUT_FILTER = "(url IS NULL OR (url NOT LIKE '%/.claude/worktrees/%' AND url NOT LIKE '%\\.claude\\worktrees\\%'))";
@@ -21856,7 +23245,7 @@ var SqliteInventoryAssetsRepository = class {
         `INSERT INTO file_access_override (id, project_id, path, access, created_at, updated_at)
            VALUES (:id, :projectId, :path, :access, :now, :now)
            ON CONFLICT (project_id, path) DO UPDATE SET access = excluded.access, updated_at = excluded.updated_at`
-      ).run({ id: randomUUID4(), projectId, path, access, now: Date.now() });
+      ).run({ id: randomUUID3(), projectId, path, access, now: Date.now() });
     }
     return true;
   }
@@ -21877,7 +23266,7 @@ var SqliteInventoryAssetsRepository = class {
         `INSERT INTO mcp_trust_override (id, asset_id, trust, created_at, updated_at)
            VALUES (:id, :assetId, :trust, :now, :now)
            ON CONFLICT (asset_id) DO UPDATE SET trust = excluded.trust, updated_at = excluded.updated_at`
-      ).run({ id: randomUUID4(), assetId, trust, now: Date.now() });
+      ).run({ id: randomUUID3(), assetId, trust, now: Date.now() });
     }
     this.configRowsCache = void 0;
     return "ok";
@@ -22174,7 +23563,7 @@ var SqliteInventoryAssetsRepository = class {
 };
 
 // ../packages/persistence/src/repositories/policies.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 var SqlitePoliciesRepository = class {
   constructor(db) {
     this.db = db;
@@ -22209,7 +23598,7 @@ var SqlitePoliciesRepository = class {
     failOpenTransaction(this.db, () => {
       for (const [category, action] of Object.entries(DEFAULT_ACTIONS)) {
         stmt.run({
-          id: randomUUID5(),
+          id: randomUUID4(),
           target: JSON.stringify({ category }),
           action,
           now: Date.now()
@@ -22229,7 +23618,7 @@ var SqlitePoliciesRepository = class {
       `INSERT INTO policies (id, scope, target, action, enabled, created_at, updated_at)
          VALUES (:id, 'global', :target, :action, 1, :now, :now)
          ON CONFLICT(scope, target) DO UPDATE SET action = excluded.action, enabled = 1, updated_at = excluded.updated_at`
-    ).run({ id: randomUUID5(), target: JSON.stringify({ category }), action, now });
+    ).run({ id: randomUUID4(), target: JSON.stringify({ category }), action, now });
   }
   // Caps every global per-category policy currently set to block/redact down
   // to warn (see warn-era-cap.ts). Rule-targeted policies are untouched.
@@ -22297,7 +23686,7 @@ var SqlitePolicyCatalogRepository = class {
 };
 
 // ../packages/persistence/src/repositories/project-files.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 var SqliteProjectFilesRepository = class {
   constructor(db) {
     this.db = db;
@@ -22329,7 +23718,7 @@ var SqliteProjectFilesRepository = class {
     const stamp = Math.max(now, maxStamp + 1);
     for (const file2 of scan2.files) {
       this.upsertStmt.run({
-        id: randomUUID6(),
+        id: randomUUID5(),
         projectId,
         path: file2.path,
         name: file2.name,
@@ -22343,7 +23732,7 @@ var SqliteProjectFilesRepository = class {
 };
 
 // ../packages/persistence/src/repositories/resolutions.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var SqliteResolutionsRepository = class {
   constructor(db, now = () => Date.now()) {
     this.db = db;
@@ -22397,7 +23786,7 @@ var SqliteResolutionsRepository = class {
    */
   insertResolution(r) {
     this.insertStmt.run({
-      id: randomUUID7(),
+      id: randomUUID6(),
       findingKey: r.findingKey,
       status: FindingStatus.parse(r.status),
       method: ResolutionMethod.parse(r.method),
@@ -22441,6 +23830,35 @@ var SqliteResolutionsRepository = class {
   }
 };
 
+// ../packages/persistence/src/repositories/rule-probe-cache.ts
+var SqliteRuleProbeCacheRepository = class {
+  constructor(db) {
+    this.db = db;
+    this.upsertStmt = db.prepare(
+      `INSERT INTO rule_probe_cache (rule_key, verdict, worst_probe_ms, checked_at)
+       VALUES (:ruleKey, :verdict, :worstProbeMs, :checkedAt)
+       ON CONFLICT (rule_key) DO UPDATE SET
+         verdict = excluded.verdict,
+         worst_probe_ms = excluded.worst_probe_ms,
+         checked_at = excluded.checked_at`
+    );
+    this.readStmt = db.prepare(
+      `SELECT verdict, worst_probe_ms AS worstProbeMs FROM rule_probe_cache WHERE rule_key = :ruleKey`
+    );
+  }
+  db;
+  upsertStmt;
+  readStmt;
+  getVerdict(ruleKey) {
+    return getRow(this.readStmt, { ruleKey });
+  }
+  setVerdict(ruleKey, verdict, worstProbeMs) {
+    failOpenTransaction(this.db, () => {
+      this.upsertStmt.run({ ruleKey, verdict, worstProbeMs, checkedAt: Date.now() });
+    });
+  }
+};
+
 // ../packages/persistence/src/repositories/scan-ledger.ts
 var SqliteScanLedgerRepository = class {
   constructor(db) {
@@ -22851,12 +24269,51 @@ var SqliteSecurityRepository = class {
 };
 
 // ../packages/persistence/src/repositories/shares.ts
-import { randomUUID as randomUUID8 } from "crypto";
-var KIND_ORDER = ["provider", "internal", "ip"];
+import { randomUUID as randomUUID7 } from "crypto";
+var MAX_EGRESS_CALL_SITES_PER_PROJECT = 5e3;
+var IN_CHUNK = 500;
+var KIND_ORDER = ["provider", "internal", "external", "ip"];
+var PLAINTEXT_TRANSPORT_SQL = "('http', 'ws')";
+var OVERRIDE_JOIN = `LEFT JOIN egress_decision_override oh ON oh.host = d.host
+             LEFT JOIN egress_decision_override ol ON ol.destination_id = d.id AND ol.host IS NULL`;
 var CALL_SITE_EMBED_CAP = 200;
 function parseNetwork(networkJson) {
   return safeJson(networkJson, null);
 }
+function capHits(all, mode) {
+  if (all.length <= MAX_EGRESS_CALL_SITES_PER_PROJECT) {
+    return { hits: [...all], droppedFiles: [], truncated: false };
+  }
+  if (mode === "walk") {
+    return {
+      hits: all.slice(0, MAX_EGRESS_CALL_SITES_PER_PROJECT),
+      droppedFiles: [],
+      truncated: true
+    };
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const hit of all) {
+    const bucket = byFile.get(hit.site.file);
+    if (bucket === void 0) byFile.set(hit.site.file, [hit]);
+    else bucket.push(hit);
+  }
+  const hits = [];
+  const droppedFiles = [];
+  for (const [file2, bucket] of byFile) {
+    if (hits.length + bucket.length > MAX_EGRESS_CALL_SITES_PER_PROJECT) droppedFiles.push(file2);
+    else hits.push(...bucket);
+  }
+  return { hits, droppedFiles, truncated: true };
+}
+function withoutDroppedFiles(reconcile, droppedFiles) {
+  if (reconcile.mode === "walk" || droppedFiles.length === 0) return reconcile;
+  const dropped = new Set(droppedFiles);
+  return {
+    mode: "ledger",
+    scannedFiles: reconcile.scannedFiles.filter((file2) => !dropped.has(file2)),
+    deletedFiles: reconcile.deletedFiles.filter((file2) => !dropped.has(file2))
+  };
+}
 function toEndpointSummary(row) {
   return {
     id: row.id,
@@ -22947,13 +24404,15 @@ var SqliteSharesRepository = class {
     const callSites = countScalar(this.db, "SELECT count(*) AS n FROM share_call_site");
     const insecure = countScalar(
       this.db,
-      "SELECT count(DISTINCT destination_id) AS n FROM share_endpoint WHERE transport = 'http'"
+      `SELECT count(DISTINCT destination_id) AS n FROM share_endpoint
+       WHERE transport IN ${PLAINTEXT_TRANSPORT_SQL}`
     );
     const needsReview = countScalar(
       this.db,
       `SELECT count(DISTINCT d.id) AS n
        FROM share_destination d
-       LEFT JOIN share_endpoint e ON e.destination_id = d.id AND e.transport = 'http'
+       LEFT JOIN share_endpoint e ON e.destination_id = d.id
+         AND e.transport IN ${PLAINTEXT_TRANSPORT_SQL}
        WHERE d.trust IN ('unverified', 'ip') OR e.id IS NOT NULL`
     );
     const kindCounts = countBy(
@@ -22963,6 +24422,7 @@ var SqliteSharesRepository = class {
     const byKind = {
       provider: kindCounts.get("provider") ?? 0,
       internal: kindCounts.get("internal") ?? 0,
+      external: kindCounts.get("external") ?? 0,
       ip: kindCounts.get("ip") ?? 0
     };
     const trustCounts = countBy(
@@ -23038,23 +24498,316 @@ var SqliteSharesRepository = class {
   // real edit from a no-such-destination.
   /**
    * Set (decision) or clear (null) the egress decision override for a destination.
-   * `null` deletes the override row → reverts to the trust default.
+   * `null` deletes the override rows → reverts to the trust default.
+   *
+   * The written row carries both the destination id and its host, so the
+   * decision re-attaches by host after the destination is pruned and
+   * re-detected under a fresh id. Rows written before the host column existed
+   * (host NULL, matched by destination id) are replaced rather than left to
+   * shadow the new one. Runs IMMEDIATE: the host lookup is read-then-write and
+   * would otherwise race a concurrent prune.
    */
   setEgressDecision(destinationId, decision) {
-    const exists = this.db.prepare("SELECT 1 FROM share_destination WHERE id = ?").get(destinationId);
-    if (exists === void 0) return false;
-    if (decision === null) {
-      this.db.prepare("DELETE FROM egress_decision_override WHERE destination_id = ?").run(destinationId);
-      return true;
+    let existed = false;
+    withTransaction(
+      this.db,
+      () => {
+        const dest = this.db.prepare("SELECT host FROM share_destination WHERE id = ?").get(destinationId);
+        if (dest === void 0) return;
+        existed = true;
+        this.db.prepare(
+          `DELETE FROM egress_decision_override
+             WHERE host = :host OR (destination_id = :destinationId AND host IS NULL)`
+        ).run({ host: dest.host, destinationId });
+        if (decision === null) return;
+        this.db.prepare(
+          `INSERT INTO egress_decision_override
+               (id, destination_id, host, decision, created_at, updated_at)
+             VALUES (:id, :destinationId, :host, :decision, :now, :now)`
+        ).run({
+          id: randomUUID7(),
+          destinationId,
+          host: dest.host,
+          decision,
+          now: Date.now()
+        });
+      },
+      "IMMEDIATE"
+    );
+    return existed;
+  }
+  /**
+   * Record one project's statically-extracted egress: reconcile the previously
+   * stored call sites against this scan, upsert destination → endpoint → call
+   * site for every hit, confirm `last_seen` on everything the project still
+   * references, and drop what no longer has evidence.
+   *
+   * Reconciliation keys on `projectKey` alone; `project` and `projectId` are
+   * display payload and never scope a delete. The whole write is one
+   * transaction: a failure leaves the project's previous inventory exactly as
+   * it was, and THROWS rather than reporting a partial write — callers decide
+   * their own fail-open behavior, and the scanner additionally withholds its
+   * ledger commit so the next scan retries.
+   *
+   * Over-cap input is truncated at a FILE boundary, and the files that lost
+   * their hits are both excluded from the reconcile delete and named in
+   * `droppedFiles`. That pairing is what keeps truncation non-destructive on
+   * the ledger path: a dropped file keeps whatever rows it already had, and its
+   * caller withholds the ledger entry so the next scan reads it again.
+   */
+  recordProjectEgress(input) {
+    const { hits, droppedFiles, truncated } = capHits(input.hits, input.reconcile.mode);
+    const reconcile = withoutDroppedFiles(input.reconcile, droppedFiles);
+    const now = Date.now();
+    let summary = {
+      destinations: 0,
+      endpoints: 0,
+      callSites: 0,
+      truncated,
+      droppedFiles
+    };
+    withTransaction(
+      this.db,
+      () => {
+        const projectId = input.projectId ?? this.knownProjectId(input.projectKey);
+        this.reconcileCallSites(input.projectKey, reconcile);
+        this.upsertHits(input, hits, projectId, now);
+        this.confirmLastSeen(input.projectKey, now);
+        this.pruneOrphans();
+        summary = { ...this.projectTotals(input.projectKey), truncated, droppedFiles };
+      },
+      "IMMEDIATE"
+    );
+    return summary;
+  }
+  // ─── Egress write internals ──────────────────────────────────────────────────
+  /**
+   * Clear the stored call sites this scan is responsible for re-creating.
+   *
+   * Each pipeline may only delete rows its own walker could have produced. The
+   * fs walk behind 'walk' mode never descends into dot-directories, so its
+   * delete excludes dot-path files — those rows are the plugin scanner's to
+   * reconcile, and deleting them here would make the two pipelines erase each
+   * other's rows on every alternating scan. 'ledger' mode names its files
+   * outright and never mass-deletes, so rows the fs walk contributed for files
+   * the scanner skips (vendored, oversize) survive it.
+   */
+  reconcileCallSites(projectKey, reconcile) {
+    if (reconcile.mode === "walk") {
+      const prefix = reconcile.walkedPrefix.replace(/\/+$/, "");
+      this.db.prepare(
+        `DELETE FROM share_call_site
+           WHERE project_key = :key
+             AND (:prefix = '' OR file = :prefix OR file LIKE :subtree ESCAPE '\\')
+             AND file NOT LIKE '.%'
+             AND file NOT LIKE '%/.%'`
+      ).run({ key: projectKey, prefix, subtree: `${escapeLikePattern(prefix)}/%` });
+      return;
+    }
+    const files = [.../* @__PURE__ */ new Set([...reconcile.scannedFiles, ...reconcile.deletedFiles])];
+    for (let i = 0; i < files.length; i += IN_CHUNK) {
+      const chunk = files.slice(i, i + IN_CHUNK);
+      this.db.prepare(
+        `DELETE FROM share_call_site
+           WHERE project_key = ? AND file IN (${placeholders(chunk.length)})`
+      ).run(projectKey, ...chunk);
+    }
+  }
+  /**
+   * Upsert every hit as destination → endpoint → call site. Destinations key on
+   * `host` and endpoints on `(destination_id, method, url)`, both shared across
+   * projects; only the call site carries `project_key`. A destination's `note`
+   * is user-owned and never overwritten. The id caches keep one upsert per
+   * distinct host and endpoint, so the first hit for a host supplies its
+   * classification for this batch.
+   */
+  upsertHits(input, hits, projectId, now) {
+    if (hits.length === 0) return;
+    const destStmt = this.db.prepare(
+      `INSERT INTO share_destination
+         (id, kind, name, host, category, trust, network_json, last_seen, provenance,
+          created_at, updated_at)
+       VALUES (:id, :kind, :name, :host, :category, :trust, :networkJson, :now, 'scan', :now, :now)
+       ON CONFLICT (host) DO UPDATE SET
+         kind = excluded.kind,
+         name = excluded.name,
+         category = excluded.category,
+         trust = excluded.trust,
+         network_json = excluded.network_json,
+         last_seen = excluded.last_seen,
+         updated_at = excluded.updated_at`
+    );
+    const destIdStmt = this.db.prepare("SELECT id FROM share_destination WHERE host = ?");
+    const endpointStmt = this.db.prepare(
+      `INSERT INTO share_endpoint
+         (id, destination_id, method, transport, url, template, data_class, last_seen,
+          created_at, updated_at)
+       VALUES (:id, :destinationId, :method, :transport, :url, :template, :dataClass, :now,
+               :now, :now)
+       ON CONFLICT (destination_id, method, url) DO UPDATE SET
+         transport = excluded.transport,
+         template = excluded.template,
+         data_class = excluded.data_class,
+         last_seen = excluded.last_seen,
+         updated_at = excluded.updated_at`
+    );
+    const endpointIdStmt = this.db.prepare(
+      "SELECT id FROM share_endpoint WHERE destination_id = ? AND method = ? AND url = ?"
+    );
+    const siteStmt = this.db.prepare(
+      `INSERT INTO share_call_site
+         (id, endpoint_id, project, project_key, file, line, snippet, dynamic, vendored,
+          project_id, created_at, updated_at)
+       VALUES (:id, :endpointId, :project, :projectKey, :file, :line, :snippet, :dynamic,
+               :vendored, :projectId, :now, :now)
+       ON CONFLICT (endpoint_id, project_key, file, line) DO UPDATE SET
+         snippet = excluded.snippet,
+         dynamic = excluded.dynamic,
+         vendored = excluded.vendored,
+         project = excluded.project,
+         project_id = COALESCE(excluded.project_id, share_call_site.project_id),
+         updated_at = excluded.updated_at`
+    );
+    const destIds = /* @__PURE__ */ new Map();
+    const endpointIds = /* @__PURE__ */ new Map();
+    for (const hit of hits) {
+      let destinationId = destIds.get(hit.host);
+      if (destinationId === void 0) {
+        destStmt.run({
+          id: randomUUID7(),
+          kind: hit.kind,
+          name: hit.name,
+          host: hit.host,
+          category: hit.category,
+          trust: hit.trust,
+          networkJson: hit.network === null ? null : JSON.stringify(hit.network),
+          now
+        });
+        destinationId = getRow(destIdStmt, [hit.host])?.id ?? "";
+        destIds.set(hit.host, destinationId);
+      }
+      const endpointKey = `${destinationId}\0${hit.method}\0${hit.url}`;
+      let endpointId = endpointIds.get(endpointKey);
+      if (endpointId === void 0) {
+        endpointStmt.run({
+          id: randomUUID7(),
+          destinationId,
+          method: hit.method,
+          transport: hit.transport,
+          url: hit.url,
+          template: boolToInt(hit.template),
+          dataClass: hit.dataClass,
+          now
+        });
+        endpointId = getRow(endpointIdStmt, [destinationId, hit.method, hit.url])?.id ?? "";
+        endpointIds.set(endpointKey, endpointId);
+      }
+      siteStmt.run({
+        id: randomUUID7(),
+        endpointId,
+        project: input.project,
+        projectKey: input.projectKey,
+        file: hit.site.file,
+        line: hit.site.line,
+        snippet: hit.site.snippet,
+        dynamic: boolToInt(hit.site.dynamic),
+        vendored: boolToInt(hit.site.vendored),
+        projectId,
+        now
+      });
     }
+  }
+  /**
+   * The source-project id this project's stored call sites already carry, if
+   * any. Only the pipeline that resolves a source project supplies one; the
+   * other passes null and inherits this, so the link stops flapping between a
+   * real id and NULL depending on which pipeline ran last. The value is a
+   * per-project attribute stored redundantly on each row, so any row's is
+   * representative.
+   */
+  knownProjectId(projectKey) {
+    return getRow(
+      this.db.prepare(
+        `SELECT project_id AS projectId FROM share_call_site
+           WHERE project_key = ? AND project_id IS NOT NULL LIMIT 1`
+      ),
+      [projectKey]
+    )?.projectId ?? null;
+  }
+  /**
+   * Stamp `last_seen` on every endpoint and destination this project still
+   * references — including rows the scan preserved rather than re-wrote, so a
+   * ledger-skipped file's references don't decay into "stale" on the page.
+   */
+  confirmLastSeen(projectKey, now) {
     this.db.prepare(
-      `INSERT INTO egress_decision_override (id, destination_id, decision, created_at, updated_at)
-         VALUES (:id, :destinationId, :decision, :now, :now)
-         ON CONFLICT (destination_id) DO UPDATE SET
-           decision = excluded.decision,
-           updated_at = excluded.updated_at`
-    ).run({ id: randomUUID8(), destinationId, decision, now: Date.now() });
-    return true;
+      `UPDATE share_endpoint SET last_seen = :now, updated_at = :now
+         WHERE id IN (SELECT DISTINCT endpoint_id FROM share_call_site WHERE project_key = :key)`
+    ).run({ now, key: projectKey });
+    this.db.prepare(
+      `UPDATE share_destination SET last_seen = :now, updated_at = :now
+         WHERE id IN (SELECT DISTINCT e.destination_id
+                      FROM share_endpoint e
+                      JOIN share_call_site c ON c.endpoint_id = e.id
+                      WHERE c.project_key = :key)`
+    ).run({ now, key: projectKey });
+  }
+  /**
+   * Drop rows left without evidence: endpoints with no call site, then
+   * destinations with no endpoint. Call sites are the only evidence either one
+   * has, so a row that lost its last one belongs to no project any more.
+   *
+   * Overrides are deleted between the two steps, and only the ones written
+   * before the host column existed. Those match a destination by id alone;
+   * because the id link is released on delete rather than cascading, leaving
+   * them would accumulate rows that match neither join arm and that nothing can
+   * reach again. Host-bearing rows deliberately survive — the host is what
+   * re-attaches a user's decision when the destination comes back.
+   */
+  pruneOrphans() {
+    this.db.exec(
+      `DELETE FROM share_endpoint
+       WHERE NOT EXISTS (SELECT 1 FROM share_call_site c WHERE c.endpoint_id = share_endpoint.id)`
+    );
+    this.db.exec(
+      `DELETE FROM egress_decision_override
+       WHERE host IS NULL
+         AND destination_id IN (
+           SELECT d.id FROM share_destination d
+           WHERE NOT EXISTS (SELECT 1 FROM share_endpoint e WHERE e.destination_id = d.id))`
+    );
+    this.db.exec(
+      `DELETE FROM share_destination
+       WHERE NOT EXISTS (
+         SELECT 1 FROM share_endpoint e WHERE e.destination_id = share_destination.id)`
+    );
+  }
+  /**
+   * Live totals for one project. Destinations and endpoints are shared across
+   * projects and carry no project column, so both are counted through the call
+   * sites that reference them.
+   */
+  projectTotals(projectKey) {
+    return {
+      destinations: countScalar(
+        this.db,
+        `SELECT count(DISTINCT e.destination_id) AS n
+         FROM share_endpoint e
+         JOIN share_call_site c ON c.endpoint_id = e.id
+         WHERE c.project_key = ?`,
+        [projectKey]
+      ),
+      endpoints: countScalar(
+        this.db,
+        "SELECT count(DISTINCT endpoint_id) AS n FROM share_call_site WHERE project_key = ?",
+        [projectKey]
+      ),
+      callSites: countScalar(
+        this.db,
+        "SELECT count(*) AS n FROM share_call_site WHERE project_key = ?",
+        [projectKey]
+      )
+    };
   }
   // ─── Raw fetchers ────────────────────────────────────────────────────────────
   mapDestRow(r) {
@@ -23074,7 +24827,8 @@ var SqliteSharesRepository = class {
   fetchDestinations(q, kinds, reviewOnly = false) {
     const cols = `d.id, d.kind, d.name, d.host, d.category, d.trust, d.note,
                   d.network_json AS networkJson, d.last_seen AS lastSeenMs,
-                  d.created_at AS createdAt, o.decision AS overrideDecision`;
+                  d.created_at AS createdAt,
+                  COALESCE(oh.decision, ol.decision) AS overrideDecision`;
     const conditions = [];
     const params = [];
     if (kinds && kinds.length > 0) {
@@ -23085,7 +24839,8 @@ var SqliteSharesRepository = class {
       conditions.push(
         `(d.trust IN ('unverified', 'ip')
           OR EXISTS (SELECT 1 FROM share_endpoint re
-                     WHERE re.destination_id = d.id AND re.transport = 'http'))`
+                     WHERE re.destination_id = d.id
+                       AND re.transport IN ${PLAINTEXT_TRANSPORT_SQL}))`
       );
     }
     let sql;
@@ -23098,7 +24853,7 @@ var SqliteSharesRepository = class {
       params.push(pattern, pattern, pattern, pattern, pattern);
       sql = `SELECT DISTINCT ${cols}
              FROM share_destination d
-             LEFT JOIN egress_decision_override o ON o.destination_id = d.id
+             ${OVERRIDE_JOIN}
              LEFT JOIN share_endpoint e ON e.destination_id = d.id
              LEFT JOIN share_call_site c ON c.endpoint_id = e.id
              ${conditions.length ? `WHERE ${conditions.join(" AND ")}` : ""}
@@ -23106,7 +24861,7 @@ var SqliteSharesRepository = class {
     } else {
       sql = `SELECT ${cols}
              FROM share_destination d
-             LEFT JOIN egress_decision_override o ON o.destination_id = d.id
+             ${OVERRIDE_JOIN}
              ${conditions.length ? `WHERE ${conditions.join(" AND ")}` : ""}
              ORDER BY d.created_at ASC, d.id ASC`;
     }
@@ -23121,9 +24876,9 @@ var SqliteSharesRepository = class {
       this.db.prepare(
         `SELECT d.id, d.kind, d.name, d.host, d.category, d.trust, d.note,
                 d.network_json AS networkJson, d.last_seen AS lastSeenMs,
-                o.decision AS overrideDecision
+                COALESCE(oh.decision, ol.decision) AS overrideDecision
          FROM share_destination d
-         LEFT JOIN egress_decision_override o ON o.destination_id = d.id
+         ${OVERRIDE_JOIN}
          WHERE d.id = ?`
       ),
       [destinationId]
@@ -23333,7 +25088,7 @@ function backupLegacyStore(file2) {
 }
 function openLocalDatabase(dir) {
   ensureDataDirSync(dir);
-  const file2 = join3(dir, DB_FILENAME);
+  const file2 = join2(dir, DB_FILENAME);
   let db = openWithPragmas(file2);
   if (isForeignSqliteLineage(db)) {
     db.close();
@@ -23352,6 +25107,7 @@ function openLocalDatabase(dir) {
   const scanLedger = new SqliteScanLedgerRepository(db);
   const exceptions = new SqliteExceptionsRepository(db);
   const resolutions = new SqliteResolutionsRepository(db);
+  const ruleProbeCache = new SqliteRuleProbeCacheRepository(db);
   const security = new SqliteSecurityRepository(db);
   const detections = new SqliteDetectionsRepository(db);
   const shares = new SqliteSharesRepository(db);
@@ -23410,7 +25166,7 @@ function openLocalDatabase(dir) {
         const definitionId = definitionIds.get(`${finding.ruleId}@${finding.version}`);
         if (!definitionId) continue;
         inspectionFindings.insertFinding({
-          id: randomUUID9(),
+          id: randomUUID8(),
           auditEventId: record2.scanEvent.id,
           inspectionDefinitionId: definitionId,
           span: finding.span,
@@ -23443,8 +25199,8 @@ function openLocalDatabase(dir) {
   }
   function reconcileWorktreeProjects(canonicalId, headRoot, worktreeRoot) {
     try {
-      const headPosix = headRoot.split(sep2).join("/");
-      const worktreePosix = worktreeRoot.split(sep2).join("/");
+      const headPosix = headRoot.split(sep).join("/");
+      const worktreePosix = worktreeRoot.split(sep).join("/");
       const exactArm = worktreeRoot === headRoot ? "" : "url IN (:worktreePosix, :worktreeWin) OR ";
       const stale = db.prepare(
         `SELECT id FROM source_project
@@ -23489,6 +25245,7 @@ function openLocalDatabase(dir) {
     scanLedger,
     exceptions,
     resolutions,
+    ruleProbeCache,
     security,
     detections,
     shares,
@@ -23520,12 +25277,12 @@ function openLocalDatabase(dir) {
 
 // ../packages/persistence/src/fingerprint.ts
 import { createHmac, randomBytes } from "crypto";
-import { chmodSync as chmodSync2, readFileSync as readFileSync3, renameSync as renameSync2, writeFileSync } from "fs";
-import { join as join4 } from "path";
+import { chmodSync as chmodSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync } from "fs";
+import { join as join3 } from "path";
 var KEY_FILENAME = "exception.key";
 var KEY_MATERIAL_BYTES = 32;
 function keyFilePath(dataDir2) {
-  return join4(dataDir2, KEY_FILENAME);
+  return join3(dataDir2, KEY_FILENAME);
 }
 function parseKeyFile(raw) {
   const parsed = JSON.parse(raw);
@@ -23562,7 +25319,7 @@ function writeKeyFile(dataDir2, key) {
 function readFingerprintKey(dataDir2) {
   let raw;
   try {
-    raw = readFileSync3(keyFilePath(dataDir2), "utf8");
+    raw = readFileSync2(keyFilePath(dataDir2), "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw err instanceof Error ? err : new Error(String(err));
@@ -23595,30 +25352,48 @@ function fingerprintValue(key, raw) {
 import { chmodSync as chmodSync3, mkdirSync as mkdirSync2, renameSync as renameSync3 } from "fs";
 import { chmod, mkdir } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { join as join5 } from "path";
+import { join as join4 } from "path";
 function defaultDataDir() {
-  return join5(homedir3(), ".aka");
+  return join4(homedir3(), ".aka");
 }
 function settingsDir(base = defaultDataDir()) {
-  return join5(base, "settings");
+  return join4(base, "settings");
 }
 function dataDir(base = defaultDataDir()) {
-  return join5(base, "data");
+  return join4(base, "data");
 }
 function dbPath(base = defaultDataDir()) {
-  return join5(dataDir(base), "aka.db");
+  return join4(dataDir(base), "aka.db");
 }
 function ensureLayoutDirSync(dir = defaultDataDir()) {
   ensureDataDirSync(dir);
 }
 
 // ../packages/persistence/src/settings.ts
-import { readFileSync as readFileSync4, renameSync as renameSync4, writeFileSync as writeFileSync2 } from "fs";
-import { join as join6 } from "path";
+import { readFileSync as readFileSync3, renameSync as renameSync4, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
+function readWorkspaceSettings(base = defaultDataDir()) {
+  const record2 = readJson(join5(settingsDir(base), "settings.json"));
+  if (!record2) return defaultWorkspaceSettings();
+  try {
+    return WorkspaceSettings.parse(record2);
+  } catch {
+    return defaultWorkspaceSettings();
+  }
+}
+function readJson(file2) {
+  let text;
+  try {
+    text = readFileSync3(file2, "utf8");
+  } catch {
+    return null;
+  }
+  return parseJsonObject(text) ?? null;
+}
 
 // ../packages/persistence/src/warn-era-cap.ts
 import { existsSync as existsSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join7 } from "path";
+import { join as join6 } from "path";
 
 // ../packages/plugin-sdk/src/provider-env.ts
 var booleanish = external_exports.string().optional().transform((v) => {
@@ -23639,9 +25414,9 @@ var providerEnvShape = {
 var ProviderEnvSchema = external_exports.object(providerEnvShape);
 
 // ../packages/plugin-sdk/src/config-inventory.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync6, realpathSync, statSync as statSync3 } from "fs";
+import { readdirSync, readFileSync as readFileSync5, realpathSync, statSync as statSync2 } from "fs";
 import { homedir as homedir4 } from "os";
-import { basename as basename2, join as join9 } from "path";
+import { basename as basename2, join as join8 } from "path";
 
 // ../rules/code-flaws/auth-jwt-no-verify.json
 var auth_jwt_no_verify_default = {
@@ -25676,8 +27451,8 @@ function bundledDetections() {
 }
 
 // ../packages/plugin-sdk/src/repo.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
-import { basename, dirname as dirname2, isAbsolute, join as join8, sep as sep3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, statSync } from "fs";
+import { basename, dirname as dirname2, isAbsolute, join as join7, sep as sep2 } from "path";
 function resolveRepoIdentity(cwd) {
   try {
     const root = findGitRoot(cwd);
@@ -25689,7 +27464,7 @@ function resolveRepoIdentity(cwd) {
       // The path fallback is normalized to posix separators (a no-op outside
       // win32) so the persistence layer's `/`-separated checkout-path patterns
       // (the ghost sweep + the read-side worktree filter) match it as written.
-      url: url2 ?? headRoot.split(sep3).join("/"),
+      url: url2 ?? headRoot.split(sep2).join("/"),
       name: (url2 ? slugFromUrl(url2) : void 0) ?? basename(headRoot)
     };
   } catch {
@@ -25715,36 +27490,36 @@ function resolveHeadRoot(cwd) {
 function findGitRoot(start) {
   let dir = start;
   for (; ; ) {
-    if (existsSync4(join8(dir, ".git"))) return dir;
+    if (existsSync4(join7(dir, ".git"))) return dir;
     const parent = dirname2(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
 }
 function resolveGitContext(root) {
-  const dotGit = join8(root, ".git");
+  const dotGit = join7(root, ".git");
   try {
-    if (statSync2(dotGit).isDirectory()) {
-      return { configPath: join8(dotGit, "config"), headRoot: root };
+    if (statSync(dotGit).isDirectory()) {
+      return { configPath: join7(dotGit, "config"), headRoot: root };
     }
   } catch {
     return void 0;
   }
   const target = /^gitdir:\s*(.+?)\s*$/m.exec(safeRead(dotGit) ?? "")?.[1];
   if (!target) return void 0;
-  const gitdir = isAbsolute(target) ? target : join8(root, target);
-  if (existsSync4(join8(gitdir, "config"))) {
-    return { configPath: join8(gitdir, "config"), headRoot: root };
+  const gitdir = isAbsolute(target) ? target : join7(root, target);
+  if (existsSync4(join7(gitdir, "config"))) {
+    return { configPath: join7(gitdir, "config"), headRoot: root };
   }
-  const commonRaw = safeRead(join8(gitdir, "commondir"))?.trim();
+  const commonRaw = safeRead(join7(gitdir, "commondir"))?.trim();
   if (!commonRaw) return void 0;
-  const commonGitDir = isAbsolute(commonRaw) ? commonRaw : join8(gitdir, commonRaw);
+  const commonGitDir = isAbsolute(commonRaw) ? commonRaw : join7(gitdir, commonRaw);
   const headRoot = basename(commonGitDir) === ".git" ? dirname2(commonGitDir) : root;
-  return { configPath: join8(commonGitDir, "config"), headRoot };
+  return { configPath: join7(commonGitDir, "config"), headRoot };
 }
 function safeRead(path) {
   try {
-    return readFileSync5(path, "utf8");
+    return readFileSync4(path, "utf8");
   } catch {
     return void 0;
   }
@@ -25782,23 +27557,57 @@ function slugFromUrl(url2) {
 }
 
 // ../packages/plugin-sdk/src/events.ts
-import { createHash as createHash4, randomUUID as randomUUID10 } from "crypto";
+import { createHash as createHash3, randomUUID as randomUUID9 } from "crypto";
 
 // ../packages/plugin-sdk/src/finding-key.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 
 // ../packages/plugin-sdk/src/inventory-resolver.ts
 import { arch, hostname as hostname3, platform, release } from "os";
 
 // ../packages/plugin-sdk/src/nudge.ts
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
-import { join as join10 } from "path";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { join as join9 } from "path";
+
+// ../packages/plugin-sdk/src/paths.ts
+import { readdirSync as readdirSync2, realpathSync as realpathSync2 } from "fs";
+import { basename as basename3, dirname as dirname3, sep as sep3 } from "path";
+function toPosix(path) {
+  return path.split(sep3).join("/");
+}
+var MAX_PROJECT_ROOT_LEVELS = 40;
+function findProjectRoot(startDir, recognizeMarker) {
+  let dir = startDir;
+  let root = null;
+  for (let level = 0; level < MAX_PROJECT_ROOT_LEVELS; level += 1) {
+    if (directoryHasMarker(dir, recognizeMarker)) root = dir;
+    const parent = dirname3(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return root ?? startDir;
+}
+function directoryHasMarker(dir, recognizeMarker) {
+  try {
+    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+      if (entry.isFile() && recognizeMarker(entry.name) != null) return true;
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+function resolveNonGitProject(startDir, recognizeMarker) {
+  const projectRoot = findProjectRoot(startDir, recognizeMarker);
+  const realRoot = realpathSync2(projectRoot);
+  return { root: projectRoot, projectKey: `path:${realRoot}`, project: basename3(realRoot) };
+}
 
 // ../packages/plugin-sdk/src/project-files.ts
-var import_ignore2 = __toESM(require_ignore(), 1);
-import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync8 } from "fs";
-import { basename as basename3, join as join11, relative as relative2, sep as sep4 } from "path";
-var SKIP_DIRS2 = /* @__PURE__ */ new Set([
+var import_ignore = __toESM(require_ignore(), 1);
+import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync7 } from "fs";
+import { basename as basename4, join as join10, relative, sep as sep4 } from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
   ".git",
   "node_modules",
   ".pnpm-store",
@@ -25815,10 +27624,10 @@ var SKIP_DIRS2 = /* @__PURE__ */ new Set([
   ".cache"
 ]);
 var MAX_FILES = 2e4;
-function readIgnoreLayer2(dir) {
+function readIgnoreLayer(dir) {
   try {
-    const content = readFileSync8(join11(dir, ".gitignore"), "utf8");
-    return { base: dir, matcher: (0, import_ignore2.default)().add(content) };
+    const content = readFileSync7(join10(dir, ".gitignore"), "utf8");
+    return { base: dir, matcher: (0, import_ignore.default)().add(content) };
   } catch {
     return void 0;
   }
@@ -25826,7 +27635,7 @@ function readIgnoreLayer2(dir) {
 function isIgnored(layers, absPath, isDir) {
   let ignored = false;
   for (const layer of layers) {
-    const rel = relative2(layer.base, absPath).split(sep4).join("/") + (isDir ? "/" : "");
+    const rel = relative(layer.base, absPath).split(sep4).join("/") + (isDir ? "/" : "");
     const verdict = layer.matcher.test(rel);
     if (verdict.ignored) ignored = true;
     else if (verdict.unignored) ignored = false;
@@ -25892,13 +27701,13 @@ function resolveProjectFiles(cwd) {
         walk.lostSubtree = true;
         return false;
       }
-      const layer = readIgnoreLayer2(dir);
+      const layer = readIgnoreLayer(dir);
       const dirLayers = layer ? [...layers, layer] : layers;
       for (const entry of dirents) {
-        const fullPath = join11(dir, entry.name);
+        const fullPath = join10(dir, entry.name);
         if (entry.isDirectory()) {
-          if (SKIP_DIRS2.has(entry.name) || isIgnored(dirLayers, fullPath, true)) continue;
-          if (existsSync5(join11(fullPath, ".git"))) continue;
+          if (SKIP_DIRS.has(entry.name) || isIgnored(dirLayers, fullPath, true)) continue;
+          if (existsSync5(join10(fullPath, ".git"))) continue;
           if (visit3(fullPath, dirLayers)) return true;
           continue;
         }
@@ -25906,10 +27715,10 @@ function resolveProjectFiles(cwd) {
         if (entry.name === ".git") continue;
         if (isIgnored(dirLayers, fullPath, false)) continue;
         if (files.length >= MAX_FILES) return true;
-        const relPath = relative2(root, fullPath).split(sep4).join("/");
+        const relPath = relative(root, fullPath).split(sep4).join("/");
         files.push({
           path: relPath,
-          name: basename3(entry.name),
+          name: basename4(entry.name),
           origin: classifyOrigin(relPath, entry.name),
           defaultAccess: "approved"
         });
@@ -25933,20 +27742,206 @@ function resolveProjectFiles(cwd) {
 }
 
 // ../packages/plugin-sdk/src/runtime.ts
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 
 // ../packages/plugin-sdk/src/suppressions.ts
 var THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1e3;
 
 // ../packages/plugin-sdk/src/throttle.ts
-import { mkdirSync as mkdirSync4, statSync as statSync4, writeFileSync as writeFileSync5 } from "fs";
-import { join as join12 } from "path";
+import { mkdirSync as mkdirSync4, statSync as statSync3, writeFileSync as writeFileSync5 } from "fs";
+import { join as join11 } from "path";
+
+// ../packages/local-ops/src/egress-record.ts
+function recordProjectEgress(db, target, egress, base = defaultDataDir()) {
+  try {
+    if (!readWorkspaceSettings(base).dataSharesInPlace) return null;
+    const abs = resolve(target);
+    const targetDir = statSync4(abs).isDirectory() ? abs : dirname4(abs);
+    const identity = resolveRepoIdentity(abs);
+    const worktreeRoot = resolveWorktreeRoot(abs);
+    let root;
+    let projectKey;
+    let project;
+    let projectId;
+    if (identity && worktreeRoot) {
+      root = worktreeRoot;
+      projectKey = `git:${identity.url}`;
+      project = identity.name;
+      projectId = db.sourceProject.upsert({
+        url: identity.url,
+        name: identity.name,
+        attributes: {}
+      });
+    } else {
+      ({ root, projectKey, project } = resolveNonGitProject(targetDir, manifestKindOf));
+      projectId = null;
+    }
+    const files = [];
+    for (const hit of egress.files) {
+      const file2 = toPosix(relative2(root, hit.file));
+      if (file2 === "" || file2.startsWith("../")) continue;
+      if (file2.startsWith(".") || file2.includes("/.")) continue;
+      files.push({ ...hit, file: file2, vendored: isVendoredPath(file2) });
+    }
+    const summary = db.shares.recordProjectEgress({
+      projectKey,
+      project,
+      projectId,
+      reconcile: { mode: "walk", walkedPrefix: toPosix(relative2(root, abs)) },
+      hits: resolveEgress(files)
+    });
+    return { ...summary, project };
+  } catch {
+    return null;
+  }
+}
+
+// ../packages/local-ops/src/fs-scan.ts
+import { createHash as createHash5, randomUUID as randomUUID11 } from "crypto";
+import { readdirSync as readdirSync4, readFileSync as readFileSync8, statSync as statSync5 } from "fs";
+import { basename as basename5, extname, join as join12, relative as relative3 } from "path";
+var import_ignore2 = __toESM(require_ignore(), 1);
+var AKAIGNORE_FILENAME = ".akaignore";
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  ".next",
+  "coverage",
+  ".turbo",
+  "build",
+  "out"
+]);
+var MAX_BYTES = 1e6;
+function readIgnoreLayer2(dir, filename) {
+  try {
+    const content = readFileSync8(join12(dir, filename), "utf8");
+    return { base: dir, matcher: (0, import_ignore2.default)().add(content) };
+  } catch {
+    return void 0;
+  }
+}
+function evaluate(layers, absPath, isDir) {
+  let state = "unmatched";
+  for (const layer of layers) {
+    const rel = toPosix(relative3(layer.base, absPath)) + (isDir ? "/" : "");
+    const verdict = layer.matcher.test(rel);
+    if (verdict.ignored) state = "ignored";
+    else if (verdict.unignored) state = "unignored";
+  }
+  return state;
+}
+function* collectFiles(target) {
+  let st;
+  try {
+    st = statSync5(target);
+  } catch {
+    return;
+  }
+  if (st.isFile()) {
+    if (st.size <= MAX_BYTES) yield { path: target, gitignored: false };
+    return;
+  }
+  if (!st.isDirectory()) return;
+  yield* visit(target, [], [], false);
+}
+function* visit(dir, markLayers, skipLayers, inIgnoredDir) {
+  const markLayer = inIgnoredDir ? void 0 : readIgnoreLayer2(dir, ".gitignore");
+  const dirMarkLayers = markLayer ? [...markLayers, markLayer] : markLayers;
+  const skipLayer = readIgnoreLayer2(dir, AKAIGNORE_FILENAME);
+  const dirSkipLayers = skipLayer ? [...skipLayers, skipLayer] : skipLayers;
+  for (const entry of readdirSync4(dir, { withFileTypes: true })) {
+    const path = join12(dir, entry.name);
+    if (entry.isDirectory()) {
+      const skipState = evaluate(dirSkipLayers, path, true);
+      if (skipState !== "unignored" && (SKIP_DIRS2.has(entry.name) || entry.name.startsWith(".") || skipState === "ignored")) {
+        continue;
+      }
+      const dirIgnored = inIgnoredDir || evaluate(dirMarkLayers, path, true) === "ignored";
+      yield* visit(path, dirMarkLayers, dirSkipLayers, dirIgnored);
+    } else if (entry.isFile()) {
+      if (evaluate(dirSkipLayers, path, false) === "ignored") continue;
+      let size;
+      try {
+        size = statSync5(path).size;
+      } catch {
+        continue;
+      }
+      if (size > MAX_BYTES) continue;
+      yield {
+        path,
+        gitignored: inIgnoredDir || evaluate(dirMarkLayers, path, false) === "ignored"
+      };
+    }
+  }
+}
+function extractFileEgress(file2, text) {
+  if (text.includes("\0")) return null;
+  const name = basename5(file2);
+  if (LOCKFILE_BASENAMES.has(name)) return null;
+  const kind = manifestKindOf(name);
+  const sdkHits = kind === null ? [] : extractManifestSdks(text, kind);
+  const endpoints = kind === null && EGRESS_CODE_EXTENSIONS.has(extname(file2)) ? extractEgress(text) : [];
+  if (endpoints.length === 0 && sdkHits.length === 0) return null;
+  return { file: file2, vendored: isVendoredPath(toPosix(file2)), endpoints, sdkHits };
+}
+function scanPathIntoStore(db, target, opts = {}) {
+  let scanned = 0;
+  let findingCount = 0;
+  const files = [];
+  const egressFiles = [];
+  for (const { path: file2, gitignored } of collectFiles(target)) {
+    let text;
+    try {
+      text = readFileSync8(file2, "utf8");
+    } catch {
+      continue;
+    }
+    scanned++;
+    const fileEgress = extractFileEgress(file2, text);
+    if (fileEgress) egressFiles.push(fileEgress);
+    const matches = scan(text, opts.rules);
+    if (matches.length === 0) continue;
+    const eventId = randomUUID11();
+    const metadata = { filePath: file2 };
+    if (gitignored) metadata.gitignored = true;
+    const event = {
+      id: eventId,
+      sourceTool: opts.sourceTool ?? "cli",
+      kind: "code_change",
+      occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      contentHash: createHash5("sha256").update(text).digest("hex"),
+      content: redact(text, matches),
+      // store the REDACTED file, never the raw secret
+      metadata
+    };
+    const findings = matches.map((m) => ({
+      id: randomUUID11(),
+      eventId,
+      ruleId: m.ruleId,
+      category: m.category,
+      severity: m.severity,
+      span: m.span,
+      maskedMatch: maskMatch(m.rawMatch),
+      // Per-pack action (monitor-by-default) when the installed snapshot supplies
+      // one, else the per-category fallback — mirrors the live path's resolveAction.
+      actionTaken: opts.ruleActions?.get(m.ruleId) ?? DEFAULT_ACTIONS[m.category],
+      confidence: m.confidence
+    }));
+    db.recordCapture(event, findings);
+    files.push({ path: file2, gitignored, findings });
+    findingCount += findings.length;
+  }
+  return { scanned, findings: findingCount, files, egress: { files: egressFiles } };
+}
 
 // ../packages/local-ops/src/project-inventory.ts
+import { statSync as statSync6 } from "fs";
+import { resolve as resolve2 } from "path";
 function recordProjectInventory(db, target) {
   try {
-    const abs = resolve(target);
-    statSync5(abs);
+    const abs = resolve2(target);
+    statSync6(abs);
     const identity = resolveRepoIdentity(abs);
     if (!identity) return null;
     const sourceProjectId2 = db.sourceProject.upsert({
@@ -26366,7 +28361,7 @@ import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync8 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { createServer } from "net";
-import { dirname as dirname3, join as join14 } from "path";
+import { dirname as dirname5, join as join14 } from "path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
 import { parseArgs as parseArgs2 } from "util";
 
@@ -26384,19 +28379,19 @@ function openUrl(url2) {
 
 // src/commands/dashboard.ts
 var require3 = createRequire2(import.meta.url);
-var here = dirname3(fileURLToPath2(import.meta.url));
+var here = dirname5(fileURLToPath2(import.meta.url));
 function pkgBase() {
-  return isSea() ? dirname3(process.execPath) : join14(here, "..");
+  return isSea() ? dirname5(process.execPath) : join14(here, "..");
 }
 function isPortFree(port) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const probe = createServer();
     probe.once("error", () => {
-      resolve2(false);
+      resolve3(false);
     });
     probe.once("listening", () => {
       probe.close(() => {
-        resolve2(true);
+        resolve3(true);
       });
     });
     probe.listen(port, "127.0.0.1");
@@ -26447,7 +28442,7 @@ async function runDashboard(argv) {
     launchStandalone(bundledServer, port, shouldOpen, url2);
     return;
   }
-  const webUiDir = dirname3(require3.resolve("@akasecurity/web-ui/package.json"));
+  const webUiDir = dirname5(require3.resolve("@akasecurity/web-ui/package.json"));
   const nextBin = require3.resolve("next/dist/bin/next", { paths: [webUiDir] });
   const startNext = () => {
     const child = spawn3(
@@ -26484,7 +28479,7 @@ function launchStandalone(serverJs, port, shouldOpen, url2) {
     return;
   }
   const child = spawn3(reinvoke.command, reinvoke.args, {
-    cwd: dirname3(serverJs),
+    cwd: dirname5(serverJs),
     stdio: ["inherit", "pipe", "inherit"],
     // Inherit the parent env so the child server sees PATH etc.; PORT/HOSTNAME tell
     // Next's standalone server where to bind (its only port input).
@@ -26703,11 +28698,11 @@ function terminalPrompter() {
     },
     isInteractive: process.stdin.isTTY && process.stdout.isTTY,
     ask(question) {
-      return new Promise((resolve2) => {
+      return new Promise((resolve3) => {
         const rl = createInterface({ input: process.stdin, output: process.stdout });
         rl.question(question, (answer) => {
           rl.close();
-          resolve2(answer);
+          resolve3(answer);
         });
       });
     },
@@ -26718,7 +28713,7 @@ function terminalPrompter() {
     // fatal signals: a security tool must never brick the terminal it was
     // invoked from.
     askHidden(question) {
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve3, reject) => {
         const stdin = process.stdin;
         process.stdout.write(question);
         stdin.setRawMode(true);
@@ -26741,7 +28736,7 @@ function terminalPrompter() {
           restore();
           process.stdout.write("\n");
           if (err) reject(err);
-          else resolve2(state.value);
+          else resolve3(state.value);
         };
         const onError = (err) => {
           finish(err);
@@ -27601,7 +29596,7 @@ async function confirm(question) {
 }
 
 // src/commands/scan.ts
-import { statSync as statSync6 } from "fs";
+import { statSync as statSync7 } from "fs";
 import { parseArgs as parseArgs7 } from "util";
 function severityRank(s) {
   return Severity.options.indexOf(s);
@@ -27611,6 +29606,10 @@ function renderInventoryLine(inv) {
   const partial2 = inv.truncated ? " (partial walk)" : "";
   return `Inventory: ${inv.name} \xB7 ${String(inv.fileCount)} project file(s) recorded${partial2}`;
 }
+function renderEgressLine(egress) {
+  const cap = egress.truncated ? ` (capped at ${String(MAX_EGRESS_CALL_SITES_PER_PROJECT)} call sites)` : "";
+  return `Data shares: ${String(egress.destinations)} destination(s) \xB7 ${String(egress.endpoints)} endpoint(s) \xB7 ${String(egress.callSites)} call site(s)${cap}`;
+}
 function runScan(argv) {
   const { values, positionals } = parseArgs7({
     args: argv,
@@ -27644,7 +29643,7 @@ function runScan(argv) {
     failOn = parsed.data;
   }
   try {
-    statSync6(target);
+    statSync7(target);
   } catch {
     process.stderr.write(`aka scan: no such file or directory: ${target}
 `);
@@ -27655,10 +29654,12 @@ function runScan(argv) {
   const db = openLocalDatabase(dataDir(home));
   let result;
   let inventory;
+  let egress;
   try {
     const { ruleActions } = db.installedPacks.installedRuleset();
     result = scanPathIntoStore(db, target, { ruleActions, sourceTool: "cli" });
     inventory = recordProjectInventory(db, target);
+    egress = recordProjectEgress(db, target, result.egress, home);
   } finally {
     db.close();
   }
@@ -27682,8 +29683,18 @@ function runScan(argv) {
       fileCount: inventory.fileCount,
       truncated: inventory.truncated
     } : null;
+    const egressJson = egress ? {
+      destinations: egress.destinations,
+      endpoints: egress.endpoints,
+      callSites: egress.callSites,
+      truncated: egress.truncated
+    } : null;
     process.stdout.write(
-      `${JSON.stringify({ target, scanned: result.scanned, findings, inventory: inventoryJson }, null, 2)}
+      `${JSON.stringify(
+        { target, scanned: result.scanned, findings, inventory: inventoryJson, egress: egressJson },
+        null,
+        2
+      )}
 `
     );
   } else {
@@ -27692,6 +29703,8 @@ function runScan(argv) {
 `
     );
     if (inventory) process.stdout.write(`${renderInventoryLine(inventory)}
+`);
+    if (egress) process.stdout.write(`${renderEgressLine(egress)}
 `);
   }
   if (failOn !== void 0) {