@odla-ai/cli 0.7.1 → 0.8.0

package/dist/{chunk-643B2AKG.js → chunk-BHAEDEL2.js}

@@ -651,6 +651,7 @@ var CAPABILITIES = {
     "push db schema/rules and configure platform AI, auth, and deployment links",
     "validate config offline and smoke-test a provisioned db environment",
     "run app-attributed hosted security discovery and independent validation without provider keys",
+    "connect/revoke source-read-only GitHub sources and drive commit-pinned hosted security jobs without PATs or provider keys",
     "let admins manage system AI policy and credentials, inspect attributed usage, and read immutable admin changes through separate short-lived capability-only approvals"
   ],
   agent: [
@@ -663,12 +664,14 @@ var CAPABILITIES = {
     "consent to production changes with --yes",
     "request destructive credential rotation explicitly",
     "review application semantics, security findings, releases, and merges",
-    "approve redacted-source disclosure before hosted security reasoning"
+    "approve redacted-source disclosure before hosted security reasoning",
+    "approve GitHub App repository access separately from redacted-snippet disclosure"
   ],
   studio: [
     "view telemetry and environment state",
     "perform manual credential recovery when the CLI's local shown-once copy is unavailable",
-    "configure system AI purposes and view app/environment/run-attributed usage"
+    "configure system AI purposes and view app/environment/run-attributed usage",
+    "connect/revoke GitHub security sources and inspect ref-to-SHA jobs, routes, retention, coverage, and normalized reports"
   ]
 };
 function printCapabilities(json = false, out = console) {
@@ -1658,6 +1661,383 @@ function formatBudget(usage) {
   return usage ? `${usage.usedCalls}/${usage.maxCalls} skipped=${usage.skippedCalls}` : "caller-managed";
 }
 
+// src/security-hosted-github.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// src/security-hosted-request.ts
+async function requestHostedSecurityJson(options, path, init, action) {
+  const platform = platformAudience(options.platform);
+  const token = hostedSecurityCredential(options.token);
+  const requestInit = {
+    ...init,
+    redirect: "error",
+    credentials: "omit",
+    cache: "no-store",
+    signal: options.signal,
+    headers: {
+      authorization: `Bearer ${token}`,
+      "content-type": "application/json",
+      ...init.headers
+    }
+  };
+  const response = await (options.fetch ?? fetch)(new URL(path, platform), requestInit);
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    const code = optionalHostedText(body.error?.code, "error code", 128);
+    const message = optionalHostedText(body.error?.message, "error message", 300);
+    throw new Error(`${action} failed (${response.status})${code ? ` ${code}` : ""}${message ? `: ${message}` : ""}`);
+  }
+  return body;
+}
+function hostedIdentifier(value, name) {
+  const result = optionalHostedText(value, name, 180);
+  if (!result || !/^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(result)) {
+    throw new Error(`${name} is invalid`);
+  }
+  return result;
+}
+function positivePolicyVersion(value, name) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new Error(`${name} is invalid`);
+  }
+  return value;
+}
+function optionalHostedText(value, name, maxLength) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string" || value.length > maxLength || /[\u0000-\u001f\u007f]/.test(value)) {
+    throw new Error(`${name} is invalid`);
+  }
+  return value;
+}
+function githubRepositoryName(value) {
+  if (typeof value !== "string" || value.length > 201) {
+    throw new Error("repository must be owner/name");
+  }
+  const parts = value.split("/");
+  const owner = parts[0] ?? "";
+  const name = (parts[1] ?? "").replace(/\.git$/i, "");
+  if (parts.length !== 2 || !/^[A-Za-z0-9](?:[A-Za-z0-9-]{0,98}[A-Za-z0-9])?$/.test(owner) || !/^[A-Za-z0-9_.-]{1,100}$/.test(name) || name === "." || name === "..") {
+    throw new Error("repository must be owner/name");
+  }
+  return `${owner}/${name}`;
+}
+function trustedGitHubInstallUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("odla.ai returned an invalid GitHub installation URL");
+  }
+  if (url.protocol !== "https:" || url.hostname !== "github.com" || url.username || url.password) {
+    throw new Error("odla.ai returned an untrusted GitHub installation URL");
+  }
+  return url.toString();
+}
+function hostedPollInterval(value = 2e3) {
+  if (!Number.isSafeInteger(value) || value < 100 || value > 3e4) {
+    throw new Error("poll interval must be 100-30000ms");
+  }
+  return value;
+}
+function hostedPollTimeout(value = 10 * 6e4) {
+  if (!Number.isSafeInteger(value) || value < 1e3 || value > 60 * 6e4) {
+    throw new Error("poll timeout must be 1000-3600000ms");
+  }
+  return value;
+}
+async function waitForHostedPoll(milliseconds, signal) {
+  if (signal?.aborted) throw signal.reason ?? new DOMException("aborted", "AbortError");
+  await new Promise((resolve7, reject) => {
+    const timer = setTimeout(resolve7, milliseconds);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timer);
+      reject(signal.reason ?? new DOMException("aborted", "AbortError"));
+    }, { once: true });
+  });
+}
+function isValidHostedSecurityPlan(value, env) {
+  if (!value || value.env !== env || !/^sha256:[a-f0-9]{64}$/.test(value.planDigest) || value.consentContract !== "odla.hosted-security-consent.v1" || value.reportProjection !== "odla.hosted-security-report.v1" || value.redactionContract !== "odla.best-effort-credential-pattern-redaction.v1" || typeof value.promptBundle !== "string" || value.promptBundle.length < 1 || value.promptBundle.length > 100 || typeof value.ready !== "boolean" || typeof value.independent !== "boolean" || value.sourceDisclosure !== "redacted" || value.targetExecution !== false || !Number.isSafeInteger(value.reportRetentionDays) || value.reportRetentionDays < 1) return false;
+  const validRoute = (route, purpose) => !!route && route.purpose === purpose && typeof route.enabled === "boolean" && typeof route.credentialReady === "boolean" && typeof route.provider === "string" && route.provider.length > 0 && route.provider.length <= 100 && typeof route.model === "string" && route.model.length > 0 && route.model.length <= 200 && Number.isSafeInteger(route.policyVersion) && route.policyVersion >= 1 && Number.isSafeInteger(route.maxCallsPerRun) && route.maxCallsPerRun >= 1 && Number.isSafeInteger(route.maxInputBytes) && route.maxInputBytes >= 1 && Number.isSafeInteger(route.maxOutputTokens) && route.maxOutputTokens >= 1;
+  return validRoute(value.routes?.discovery, "security.discovery") && validRoute(value.routes?.validation, "security.validation");
+}
+function hostedSecurityCredential(value) {
+  if (typeof value !== "string" || value.length < 8 || value.length > 8192 || /\s|[\u0000-\u001f\u007f]/.test(value)) {
+    throw new Error("Hosted security requires an injected odla developer token");
+  }
+  return value;
+}
+
+// src/security-hosted-github.ts
+async function connectGitHubSecuritySource(options) {
+  const out = options.stdout ?? console;
+  const repository = githubRepositoryName(options.repository);
+  const attempt = await requestHostedSecurityJson(
+    options,
+    "/registry/github/connect",
+    {
+      method: "POST",
+      body: JSON.stringify({
+        appId: hostedIdentifier(options.appId, "appId"),
+        env: hostedIdentifier(options.env, "env"),
+        repository
+      })
+    },
+    "start GitHub connection"
+  );
+  const serverExpiry = Date.parse(attempt?.expiresAt ?? "");
+  if (!attempt?.attemptId || !attempt.installUrl || !Number.isFinite(serverExpiry)) {
+    throw new Error("odla.ai returned an invalid GitHub connection attempt");
+  }
+  const installUrl = trustedGitHubInstallUrl(attempt.installUrl);
+  out.log(`GitHub approval: ${installUrl}`);
+  if (options.open !== false) {
+    await (options.openInstallUrl ?? openUrl)(installUrl);
+    out.log("github: opened installation approval in your browser");
+  }
+  const interval = hostedPollInterval(options.pollIntervalMs);
+  const now = options.now ?? Date.now;
+  const deadline = Math.min(serverExpiry, now() + hostedPollTimeout(options.pollTimeoutMs));
+  const wait = options.wait ?? waitForHostedPoll;
+  while (true) {
+    const state = await requestHostedSecurityJson(
+      options,
+      `/registry/github/connect/${encodeURIComponent(attempt.attemptId)}`,
+      {},
+      "check GitHub connection"
+    );
+    if (state.status !== "pending") {
+      if (state.status === "connected") return state;
+      throw new Error(`GitHub connection ${state.status}${state.failureCode ? `: ${state.failureCode}` : ""}`);
+    }
+    if (now() >= deadline) throw new Error("GitHub connection approval timed out");
+    await wait(Math.min(interval, Math.max(0, deadline - now())), options.signal);
+  }
+}
+async function listGitHubSecuritySources(options) {
+  const appId = hostedIdentifier(options.appId, "appId");
+  const env = hostedIdentifier(options.env, "env");
+  const body = await requestHostedSecurityJson(
+    options,
+    `/registry/apps/${encodeURIComponent(appId)}/github/sources?env=${encodeURIComponent(env)}`,
+    {},
+    "list GitHub security sources"
+  );
+  return Array.isArray(body.sources) ? body.sources : [];
+}
+async function disconnectGitHubSecuritySource(options) {
+  const appId = hostedIdentifier(options.appId, "appId");
+  const sourceId = hostedIdentifier(options.sourceId, "sourceId");
+  await requestHostedSecurityJson(
+    options,
+    `/registry/apps/${encodeURIComponent(appId)}/github/sources/${encodeURIComponent(sourceId)}`,
+    { method: "DELETE" },
+    "disconnect GitHub security source"
+  );
+}
+function repositoryFromGitRemote(remoteInput) {
+  const remote = remoteInput.trim();
+  const scp = /^git@github\.com:([^/\s]+)\/([^/\s]+?)\/?$/.exec(remote);
+  if (scp) return githubRepositoryName(`${scp[1]}/${scp[2].replace(/\.git$/, "")}`);
+  let url;
+  try {
+    url = new URL(remote);
+  } catch {
+    throw new Error("origin must be a github.com HTTPS or SSH repository URL");
+  }
+  if (url.hostname !== "github.com" || url.protocol !== "https:" && url.protocol !== "ssh:") {
+    throw new Error("origin must be a github.com HTTPS or SSH repository URL");
+  }
+  if (url.password || url.protocol === "https:" && url.username || url.search || url.hash) {
+    throw new Error("credential-bearing GitHub origin URLs are not accepted");
+  }
+  const parts = url.pathname.replace(/^\/+|\/+$/g, "").split("/");
+  if (parts.length !== 2) {
+    throw new Error("origin must identify one GitHub owner/name repository");
+  }
+  return githubRepositoryName(`${parts[0]}/${parts[1].replace(/\.git$/, "")}`);
+}
+async function inferGitHubRepository(cwd = process.cwd(), readOrigin = defaultReadOrigin) {
+  let remote;
+  try {
+    remote = await readOrigin(cwd);
+  } catch {
+    throw new Error("Could not read git origin; pass --repo owner/name");
+  }
+  return repositoryFromGitRemote(remote);
+}
+async function defaultReadOrigin(cwd) {
+  const result = await promisify(execFile)(
+    "git",
+    ["remote", "get-url", "origin"],
+    { cwd, encoding: "utf8" }
+  );
+  return result.stdout;
+}
+
+// src/security-hosted-intent.ts
+async function getHostedSecurityIntent(options) {
+  const appId = hostedIdentifier(options.appId, "appId");
+  const env = hostedIdentifier(options.env, "env");
+  const sourceId = hostedIdentifier(options.sourceId, "sourceId");
+  const ref = optionalHostedText(options.ref, "ref", 255);
+  const query = new URLSearchParams({ env, sourceId });
+  if (ref) query.set("ref", ref);
+  if (options.profile) query.set("profile", options.profile);
+  const response = await requestHostedSecurityJson(
+    options,
+    `/registry/apps/${encodeURIComponent(appId)}/security/intent?${query.toString()}`,
+    {},
+    "read hosted security execution intent"
+  );
+  if (!isValidHostedSecurityPlan(response.plan, env) || !isValidIntent(response.intent, { appId, env, sourceId })) {
+    throw new Error("odla.ai returned an invalid hosted security execution intent");
+  }
+  if (response.intent.planDigest !== response.plan.planDigest) {
+    throw new Error("odla.ai returned a hosted security intent for a different processing plan");
+  }
+  return response;
+}
+function isValidIntent(value, expected) {
+  return !!value && value.executionContract === "odla.hosted-security-execution-consent.v1" && /^sha256:[a-f0-9]{64}$/.test(value.executionDigest) && /^sha256:[a-f0-9]{64}$/.test(value.planDigest) && value.appId === expected.appId && value.env === expected.env && value.sourceId === expected.sourceId && typeof value.repository === "string" && value.repository.length > 2 && value.repository.length <= 201 && typeof value.defaultBranch === "string" && value.defaultBranch.length > 0 && value.defaultBranch.length <= 255 && typeof value.requestedRef === "string" && value.requestedRef.length > 0 && value.requestedRef.length <= 255 && !/[\u0000-\u001f\u007f]/.test(value.requestedRef) && ["odla", "cloudflare-app", "generic"].includes(value.profile) && value.sourceDisclosure === "redacted";
+}
+
+// src/security-hosted-jobs.ts
+async function getHostedSecurityPlan(options) {
+  const appId = hostedIdentifier(options.appId, "appId");
+  const env = hostedIdentifier(options.env, "env");
+  const plan = await requestHostedSecurityJson(
+    options,
+    `/registry/apps/${encodeURIComponent(appId)}/security/plan?env=${encodeURIComponent(env)}`,
+    {},
+    "read hosted security disclosure plan"
+  );
+  if (!isValidHostedSecurityPlan(plan, env)) {
+    throw new Error("odla.ai returned an invalid hosted security disclosure plan");
+  }
+  return plan;
+}
+async function startHostedSecurityJob(options) {
+  if (options.sourceDisclosureAck !== "redacted") {
+    throw new Error("Hosted GitHub security requires sourceDisclosureAck=redacted; repository access alone is not disclosure consent");
+  }
+  const appId = hostedIdentifier(options.appId, "appId");
+  const env = hostedIdentifier(options.env, "env");
+  const sourceId = hostedIdentifier(options.sourceId, "sourceId");
+  const ref = optionalHostedText(options.ref, "ref", 255);
+  const expectedPlanDigest = securityPlanDigest(options.expectedPlanDigest);
+  const expectedExecutionDigest = securityExecutionDigest(options.expectedExecutionDigest);
+  const expectedPolicyVersions = {
+    discovery: positivePolicyVersion(
+      options.expectedPolicyVersions?.discovery,
+      "expected discovery policy version"
+    ),
+    validation: positivePolicyVersion(
+      options.expectedPolicyVersions?.validation,
+      "expected validation policy version"
+    )
+  };
+  let body;
+  try {
+    body = await requestHostedSecurityJson(
+      options,
+      `/registry/apps/${encodeURIComponent(appId)}/security/jobs`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          env,
+          sourceId,
+          ...ref ? { ref } : {},
+          ...options.profile ? { profile: options.profile } : {},
+          ...options.clientRequestId ? { clientRequestId: hostedIdentifier(options.clientRequestId, "clientRequestId") } : {},
+          sourceDisclosure: "redacted",
+          expectedPlanDigest,
+          expectedExecutionDigest,
+          expectedPolicyVersions
+        })
+      },
+      "start hosted security job"
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/\b(?:plan_conflict|policy_conflict|intent_conflict|security_ai_not_ready)\b/.test(message)) {
+      throw new Error("Hosted security plan or execution intent changed or became unavailable after review; fetch a fresh intent and explicitly acknowledge its digest before enqueueing again", { cause: error });
+    }
+    throw error;
+  }
+  if (!body.job?.jobId) {
+    throw new Error("odla.ai returned an invalid hosted security job");
+  }
+  return body.job;
+}
+async function getHostedSecurityJob(options) {
+  const body = await requestHostedSecurityJson(
+    options,
+    hostedJobPath(options.appId, options.jobId),
+    {},
+    "read hosted security job"
+  );
+  if (!body.job?.jobId) throw new Error("odla.ai returned an invalid hosted security job");
+  return body.job;
+}
+async function listHostedSecurityJobs(options) {
+  const appId = hostedIdentifier(options.appId, "appId");
+  const env = hostedIdentifier(options.env, "env");
+  const body = await requestHostedSecurityJson(
+    options,
+    `/registry/apps/${encodeURIComponent(appId)}/security/jobs?env=${encodeURIComponent(env)}`,
+    {},
+    "list hosted security jobs"
+  );
+  return Array.isArray(body.jobs) ? body.jobs : [];
+}
+async function followHostedSecurityJob(options) {
+  const interval = hostedPollInterval(options.pollIntervalMs);
+  const now = options.now ?? Date.now;
+  const deadline = now() + hostedPollTimeout(options.pollTimeoutMs ?? 60 * 6e4);
+  const wait = options.wait ?? waitForHostedPoll;
+  let prior = "";
+  while (true) {
+    const job = await getHostedSecurityJob(options);
+    const fingerprint = `${job.status}:${job.updatedAt}`;
+    if (fingerprint !== prior) options.onUpdate?.(Object.freeze({ ...job }));
+    prior = fingerprint;
+    if (isTerminalHostedSecurityStatus(job.status)) return job;
+    if (now() >= deadline) {
+      throw new Error(`Hosted security job ${job.jobId} did not finish before the polling deadline`);
+    }
+    await wait(Math.min(interval, Math.max(0, deadline - now())), options.signal);
+  }
+}
+async function getHostedSecurityReport(options) {
+  return requestHostedSecurityJson(
+    options,
+    `${hostedJobPath(options.appId, options.jobId)}/report`,
+    {},
+    "read hosted security report"
+  );
+}
+function isTerminalHostedSecurityStatus(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+function hostedJobPath(appIdInput, jobIdInput) {
+  const appId = hostedIdentifier(appIdInput, "appId");
+  const jobId = hostedIdentifier(jobIdInput, "jobId");
+  return `/registry/apps/${encodeURIComponent(appId)}/security/jobs/${encodeURIComponent(jobId)}`;
+}
+function securityPlanDigest(value) {
+  if (!/^sha256:[a-f0-9]{64}$/.test(value)) {
+    throw new Error("expected plan digest must be a sha256 digest from security plan");
+  }
+  return value;
+}
+function securityExecutionDigest(value) {
+  if (!/^sha256:[a-f0-9]{64}$/.test(value)) {
+    throw new Error("expected execution digest must be a sha256 digest from security intent");
+  }
+  return value;
+}
+
 // src/skill.ts
 import { existsSync as existsSync7, lstatSync, mkdirSync as mkdirSync3, readFileSync as readFileSync5, readdirSync, writeFileSync as writeFileSync3 } from "fs";
 import { homedir } from "os";
@@ -1992,9 +2372,6 @@ async function safeText3(res) {
   }
 }
 
-// src/cli.ts
-import { findingsAtOrAbove } from "@odla-ai/security";
-
 // src/argv.ts
 function parseArgv(argv) {
   const positionals = [];
@@ -2070,6 +2447,65 @@ function addOption(options, name, value) {
   else options[name] = [String(current), String(value)];
 }
 
+// src/admin-command.ts
+async function adminCommand(parsed) {
+  const area = parsed.positionals[1];
+  const action = parsed.positionals[2];
+  const credentialSet = action === "credential" && parsed.positionals[3] === "set";
+  const credentials = action === "credentials";
+  const models = action === "models";
+  const usage = action === "usage";
+  const audit = action === "audit";
+  if (area !== "ai" || action !== "show" && action !== "set" && !credentialSet && !credentials && !models && !usage && !audit) {
+    throw new Error('unknown admin command. Try "odla-ai admin ai show".');
+  }
+  assertArgs(parsed, [
+    "platform",
+    "json",
+    "open",
+    "provider",
+    "model",
+    "enabled",
+    "max-input-bytes",
+    "max-output-tokens",
+    "max-calls-per-run",
+    "from-env",
+    "stdin",
+    "discovery-provider",
+    "discovery-model",
+    "validation-provider",
+    "validation-model",
+    "app-id",
+    "env",
+    "run-id",
+    "limit"
+  ], credentialSet ? 5 : action === "set" ? 4 : 3);
+  await adminAi({
+    action: credentialSet ? "credential-set" : credentials ? "credentials" : models ? "models" : usage ? "usage" : audit ? "audit" : action,
+    purpose: action === "set" ? parsed.positionals[3] : void 0,
+    provider: stringOpt(parsed.options.provider),
+    model: stringOpt(parsed.options.model),
+    enabled: boolOpt(parsed.options.enabled),
+    maxInputBytes: numberOpt(parsed.options["max-input-bytes"], "--max-input-bytes"),
+    maxOutputTokens: numberOpt(parsed.options["max-output-tokens"], "--max-output-tokens"),
+    maxCallsPerRun: numberOpt(parsed.options["max-calls-per-run"], "--max-calls-per-run"),
+    platform: stringOpt(parsed.options.platform),
+    json: parsed.options.json === true,
+    open: parsed.options.open === false ? false : parsed.options.open === true ? true : void 0,
+    credentialProvider: credentialSet ? parsed.positionals[4] : void 0,
+    fromEnv: stringOpt(parsed.options["from-env"]),
+    stdin: parsed.options.stdin === true,
+    discoveryProvider: stringOpt(parsed.options["discovery-provider"]),
+    discoveryModel: stringOpt(parsed.options["discovery-model"]),
+    validationProvider: stringOpt(parsed.options["validation-provider"]),
+    validationModel: stringOpt(parsed.options["validation-model"]),
+    appId: stringOpt(parsed.options["app-id"]),
+    env: stringOpt(parsed.options.env),
+    runId: stringOpt(parsed.options["run-id"]),
+    limit: numberOpt(parsed.options.limit, "--limit")
+  });
+}
+
 // src/help.ts
 import { readFileSync as readFileSync6 } from "fs";
 function cliVersion() {
@@ -2093,6 +2529,13 @@ Usage:
   odla-ai admin ai credential set <provider> (--from-env <NAME>|--stdin)
   odla-ai admin ai usage [--app-id <id>] [--env <env>] [--run-id <id>] [--limit <1-500>] [--json]
   odla-ai admin ai audit [--limit <1-200>] [--json]
+  odla-ai security github connect [--repo owner/name] [--env dev] [--no-open]
+  odla-ai security github disconnect --source <id> [--env dev] [--yes]
+  odla-ai security plan [--env dev] [--json]
+  odla-ai security sources [--env dev] [--json]
+  odla-ai security run --source <id> --plan-digest <sha256:...> --ack-redacted-source [--ref <branch|tag|sha>] [--env dev] [--no-follow]
+  odla-ai security status <job-id> [--follow] [--json]
+  odla-ai security report <job-id> [--json]
   odla-ai security run [target] --ack-redacted-source [--env dev] [--profile odla] [--fail-on high]
   odla-ai security run [target] --self --ack-redacted-source
   odla-ai provision [--config odla.config.mjs] [--dry-run] [--push-secrets] [--rotate-o11y-token] [--write-dev-vars[=path]] [--yes]
@@ -2107,7 +2550,7 @@ Commands:
   doctor       Validate and summarize the project config without network calls.
   capabilities Show what the CLI automates vs agent edits and human checkpoints.
   admin        Manage platform-funded AI routing/credentials/usage with narrow device grants.
-  security     Run hosted discovery + independent validation with app/run attribution.
+  security     Connect GitHub sources and run commit-pinned hosted reviews, or scan a local snapshot.
   provision    Register services, configure them, persist credentials, optionally push secrets.
   smoke        Verify local credentials, public-config, live schema, and db aggregate.
   skill        Same installer; --agent accepts all, claude, codex, cursor,
@@ -2123,11 +2566,467 @@ Safety:
   preflights Wrangler before any shown-once issuance or destructive rotation.
   Provision opens the approval page automatically in interactive terminals;
   use --open to force browser launch or --no-open to suppress it.
+  GitHub security uses source-read-only access plus optional metadata-only Checks write: the CLI never asks
+  for a PAT or provider key. GitHub read access is separate from the explicit
+  --ack-redacted-source consent and the exact --plan-digest printed by security
+  plan are required before bounded snippets reach System AI.
+  Run security plan first to inspect the admin-selected providers, models,
+  per-route bounds, credential readiness, retention, no-execution boundary,
+  and digest that binds consent to that exact plan.
 `);
 }
 
+// src/harness-options.ts
+function harnessList(parsed) {
+  const selected = [
+    ...harnessOption(parsed.options.agent, "--agent"),
+    ...harnessOption(parsed.options.harness, "--harness")
+  ];
+  return selected.length ? selected : ["all"];
+}
+function harnessOption(value, flag) {
+  if (value === void 0) return [];
+  if (typeof value === "boolean") throw new Error(`${flag} requires a harness name`);
+  const raw = Array.isArray(value) ? value : [value];
+  const parts = raw.flatMap((item) => item.split(","));
+  if (parts.some((item) => !item.trim())) {
+    throw new Error(`${flag} requires a harness name`);
+  }
+  return parts.map((item) => item.trim());
+}
+
+// src/security-command-context.ts
+import { createInterface } from "readline/promises";
+async function hostedSecurityContext(parsed, dependencies) {
+  const configPath = stringOpt(parsed.options.config) ?? "odla.config.mjs";
+  const cfg = await loadProjectConfig(configPath);
+  const env = stringOpt(parsed.options.env) ?? (cfg.envs.includes("dev") ? "dev" : cfg.envs[0]);
+  if (!env || !cfg.envs.includes(env)) {
+    throw new Error(`env "${env ?? ""}" is not declared in ${configPath}`);
+  }
+  const platform = platformAudience(stringOpt(parsed.options.platform) ?? cfg.platformUrl);
+  if (platformAudience(cfg.platformUrl) !== platform) {
+    throw new Error("--platform cannot reuse a project developer token from another platform; update odla.config.mjs and authenticate there");
+  }
+  const doFetch = dependencies.fetch ?? fetch;
+  const stdout = dependencies.stdout ?? console;
+  const open = parsed.options.open === false ? false : parsed.options.open === true ? true : void 0;
+  const token = await getDeveloperToken(
+    cfg,
+    { configPath, open, openApprovalUrl: dependencies.openUrl },
+    doFetch,
+    stdout
+  );
+  return { platform, token, appId: cfg.app.id, env, fetch: doFetch, stdout };
+}
+async function interactiveConfirmation(message, dependencies) {
+  if (dependencies.confirm) return dependencies.confirm(message);
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+  const prompt = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await prompt.question(`${message} [y/N] `);
+    return /^y(?:es)?$/i.test(answer.trim());
+  } finally {
+    prompt.close();
+  }
+}
+function requiredSecurityPositional(parsed, index, label) {
+  const value = parsed.positionals[index];
+  if (!value) throw new Error(`${label} is required`);
+  return value;
+}
+function securityProfile(value) {
+  if (value === void 0) return void 0;
+  if (value === "odla" || value === "cloudflare-app" || value === "generic") return value;
+  throw new Error("--profile must be odla, cloudflare-app, or generic");
+}
+
+// src/security-command-output.ts
+function printHostedSecurityPlan(out, plan, appId) {
+  out.log(`Hosted security plan for ${appId}/${plan.env}: ${plan.ready ? "ready" : "not ready"}`);
+  out.log(`  plan digest: ${plan.planDigest}`);
+  out.log(`  consent/report/redaction: ${plan.consentContract} \xB7 ${plan.reportProjection} \xB7 ${plan.redactionContract}`);
+  out.log(`  prompt bundle: ${plan.promptBundle}`);
+  printHostedSecurityPlanRoute(out, "discovery", plan.routes.discovery);
+  printHostedSecurityPlanRoute(out, "validation", plan.routes.validation);
+  out.log(`  independent validation: ${plan.independent ? "yes" : "no"}`);
+  out.log("  source disclosure: bounded best-effort credential-pattern-redacted snippets may be sent through odla.ai to the selected providers");
+  out.log(`  retained report: model-derived prose and repository-relative paths for up to ${plan.reportRetentionDays} days; treat it as sensitive`);
+  out.log("  target execution: disabled");
+  out.log(`  to approve this exact plan, run security run --source <id> --plan-digest ${plan.planDigest} --ack-redacted-source`);
+}
+function printHostedSecurityIntent(out, intent) {
+  out.log(`Hosted security execution intent for ${intent.appId}/${intent.env}:`);
+  out.log(`  execution digest: ${intent.executionDigest}`);
+  out.log(`  contract: ${intent.executionContract}`);
+  out.log(`  source: ${intent.repository} (${intent.sourceId})`);
+  out.log(`  ref: ${intent.requestedRef ?? `default branch (${intent.defaultBranch})`}`);
+  out.log(`  profile: ${intent.profile}`);
+  out.log(`  disclosure: ${intent.sourceDisclosure} \xB7 plan ${intent.planDigest}`);
+}
+function assertHostedSecurityPlanReady(plan) {
+  const reasons = [];
+  for (const [label, route] of Object.entries(plan.routes)) {
+    if (!route.enabled) reasons.push(`${label} is disabled`);
+    if (!route.credentialReady) reasons.push(`${label} provider credential is unavailable`);
+  }
+  if (!plan.independent) reasons.push("discovery and validation are not independently routed");
+  if (plan.ready && reasons.length === 0) return;
+  if (!plan.ready && reasons.length === 0) reasons.push("the platform marked the plan unavailable");
+  throw new Error(`hosted security is not ready${reasons.length ? `: ${reasons.join("; ")}` : ""}. Ask a platform admin to update System AI security policy or credentials`);
+}
+function printHostedJob(out, job, platform, appId) {
+  out.log(`security job ${job.jobId}: ${job.status}`);
+  out.log(`  source: ${job.repository} ${job.requestedRef ?? "default"} -> ${job.commitSha ?? "resolving"}`);
+  if (job.routes) {
+    out.log(`  discovery: ${routeLabel(job.routes.discovery)}`);
+    out.log(`  validation: ${routeLabel(job.routes.validation)}`);
+  } else {
+    out.log("  routes: platform System AI policy (assigned when analysis starts)");
+  }
+  out.log(`  disclosure: ${job.sourceDisclosure} snippets \xB7 metadata retained up to ${job.retentionDays} days`);
+  out.log(`  consent: plan ${job.planDigest} \xB7 execution ${job.executionDigest} (${job.executionContract})`);
+  if (job.coverageStatus || job.coverage) printHostedCoverage(out, job);
+  if (job.counts) {
+    out.log(`  findings: confirmed=${job.counts.confirmed} needs_reproduction=${job.counts.needsReproduction} candidates=${job.counts.candidates}`);
+  }
+  if (job.errorCode) out.log(`  failure: ${job.errorCode}`);
+  const url = new URL("/studio", platform);
+  url.searchParams.set("app", appId);
+  url.searchParams.set("env", job.env);
+  url.searchParams.set("tab", "security");
+  url.searchParams.set("job", job.jobId);
+  out.log(`  Studio: ${url.toString()}`);
+}
+function printHostedReport(out, report) {
+  out.log(`security report ${report.jobId}: ${report.repository}@${report.revision}`);
+  out.log(`  coverage: ${report.coverageStatus} cells=${report.metrics.coverageCells} shallow=${report.metrics.shallowCells} blocked=${report.metrics.blockedCells} unscheduled=${report.metrics.unscheduledCells} budget_exhausted=${report.metrics.budgetExhaustedCells}`);
+  out.log(`  findings: confirmed=${report.metrics.confirmed} needs_reproduction=${report.metrics.needsReproduction} candidates=${report.metrics.candidates} rejected=${report.metrics.rejected}`);
+  out.log(`  discovery: ${report.provenance.discovery?.provider ?? "unknown"}/${report.provenance.discovery?.model ?? "unknown"}`);
+  out.log(`  validation: ${report.provenance.validation?.provider ?? "unknown"}/${report.provenance.validation?.model ?? "unknown"} independent=${String(report.provenance.independentValidation)}`);
+  for (const finding of report.findings) {
+    const location = finding.locations[0];
+    out.log(`  [${finding.severity}] ${finding.title}${location ? ` (${location.path}:${location.line})` : ""} \xB7 ${finding.disposition}`);
+  }
+  for (const limitation of report.limitations) out.log(`  limitation: ${limitation}`);
+}
+function enforceHostedReportGate(report, parsed, out, emitSuccess) {
+  const failOn = hostedSeverity(stringOpt(parsed.options["fail-on"]) ?? "high", "--fail-on");
+  const candidateValue = parsed.options["fail-on-candidates"];
+  const failOnCandidates = candidateValue === false ? void 0 : hostedSeverity(stringOpt(candidateValue) ?? "critical", "--fail-on-candidates");
+  const atOrAbove = (severity, threshold) => HOSTED_SEVERITIES.indexOf(severity) >= HOSTED_SEVERITIES.indexOf(threshold);
+  const confirmed = report.findings.filter((finding) => finding.disposition === "confirmed" && atOrAbove(finding.severity, failOn));
+  const leads = failOnCandidates ? report.findings.filter((finding) => finding.disposition !== "confirmed" && atOrAbove(finding.severity, failOnCandidates)) : [];
+  const incomplete = report.coverageStatus !== "complete" && parsed.options["allow-incomplete"] !== true;
+  if (confirmed.length || leads.length || incomplete) {
+    throw new Error(`hosted security gate failed: ${confirmed.length} confirmed >= ${failOn}; ${leads.length} leads >= ${failOnCandidates ?? "disabled"}${incomplete ? `; coverage ${report.coverageStatus}` : ""}`);
+  }
+  if (emitSuccess) {
+    out.log(`security gate passed: 0 confirmed >= ${failOn}; 0 leads >= ${failOnCandidates ?? "disabled"}; coverage ${report.coverageStatus}. This is not proof that the application is secure.`);
+  }
+}
+function printHostedSecurityPlanRoute(out, label, route) {
+  const readiness = route.enabled && route.credentialReady ? "ready" : [
+    route.enabled ? void 0 : "disabled",
+    route.credentialReady ? void 0 : "credential unavailable"
+  ].filter(Boolean).join(", ");
+  out.log(`  ${label}: ${route.provider}/${route.model} \xB7 policy v${route.policyVersion} \xB7 ${readiness}`);
+  out.log(`    bounds: ${route.maxCallsPerRun} calls/run \xB7 ${route.maxInputBytes} input bytes/call \xB7 ${route.maxOutputTokens} output tokens/call`);
+}
+function printHostedCoverage(out, job) {
+  const coverage = job.coverage;
+  out.log(`  coverage: ${job.coverageStatus ?? "pending"}${coverage?.completeCells !== void 0 ? ` ${coverage.completeCells}/${coverage.totalCells ?? "?"}` : ""}${coverage?.shallowCells ? ` shallow=${coverage.shallowCells}` : ""}${coverage?.blockedCells ? ` blocked=${coverage.blockedCells}` : ""}${coverage?.unscheduledCells ? ` unscheduled=${coverage.unscheduledCells}` : ""}${coverage?.budgetExhaustedCells ? ` budget_exhausted=${coverage.budgetExhaustedCells}` : ""}`);
+}
+function routeLabel(route) {
+  return `${route.provider}/${route.model}${route.policyVersion ? ` policy v${route.policyVersion}` : ""}`;
+}
+var HOSTED_SEVERITIES = ["informational", "low", "medium", "high", "critical"];
+function hostedSeverity(value, flag) {
+  if (HOSTED_SEVERITIES.includes(value)) {
+    return value;
+  }
+  throw new Error(`${flag} must be informational, low, medium, high, or critical`);
+}
+
+// src/security-run-command.ts
+import { findingsAtOrAbove } from "@odla-ai/security";
+async function runSourceSecurityCommand(parsed, dependencies, sourceId) {
+  assertArgs(parsed, [
+    "config",
+    "env",
+    "profile",
+    "platform",
+    "source",
+    "ref",
+    "follow",
+    "open",
+    "json",
+    "ack-redacted-source",
+    "plan-digest",
+    "fail-on",
+    "fail-on-candidates",
+    "allow-incomplete"
+  ], 2);
+  const follow = parsed.options.follow !== false;
+  if (!follow && (parsed.options["fail-on"] !== void 0 || parsed.options["fail-on-candidates"] !== void 0 || parsed.options["allow-incomplete"] !== void 0)) {
+    throw new Error("hosted security gate options require following the job; remove --no-follow");
+  }
+  const acknowledgedDigest = requiredString(parsed.options["plan-digest"], "--plan-digest");
+  const context = await hostedSecurityContext(parsed, dependencies);
+  const plan = await getHostedSecurityPlan(context);
+  if (parsed.options.json !== true) printHostedSecurityPlan(context.stdout, plan, context.appId);
+  assertHostedSecurityPlanReady(plan);
+  if (acknowledgedDigest !== plan.planDigest) {
+    throw new Error(`--plan-digest does not match the current hosted security plan (${plan.planDigest}); review and explicitly acknowledge the current digest`);
+  }
+  const requestedRef = stringOpt(parsed.options.ref);
+  const requestedProfile = securityProfile(stringOpt(parsed.options.profile));
+  const preview = await getHostedSecurityIntent({
+    ...context,
+    sourceId,
+    ref: requestedRef,
+    profile: requestedProfile
+  });
+  if (parsed.options.json !== true) printHostedSecurityIntent(context.stdout, preview.intent);
+  if (preview.plan.planDigest !== plan.planDigest || preview.intent.planDigest !== plan.planDigest) {
+    throw new Error(`hosted security plan changed while previewing execution (${preview.plan.planDigest}); review and explicitly acknowledge the current plan digest`);
+  }
+  const job = await startHostedSecurityJob({
+    ...context,
+    sourceId,
+    ref: requestedRef,
+    profile: requestedProfile,
+    clientRequestId: crypto.randomUUID(),
+    sourceDisclosureAck: parsed.options["ack-redacted-source"] === true ? "redacted" : void 0,
+    expectedPlanDigest: plan.planDigest,
+    expectedExecutionDigest: preview.intent.executionDigest,
+    expectedPolicyVersions: {
+      discovery: plan.routes.discovery.policyVersion,
+      validation: plan.routes.validation.policyVersion
+    }
+  });
+  const result = follow ? await followHostedSecurityJob({
+    ...context,
+    jobId: job.jobId,
+    wait: dependencies.pollWait,
+    onUpdate: parsed.options.json === true ? void 0 : (value) => printHostedJob(context.stdout, value, context.platform, context.appId)
+  }) : job;
+  if (!follow) {
+    if (parsed.options.json === true) {
+      context.stdout.log(JSON.stringify({ plan, intent: preview.intent, job: result }, null, 2));
+    } else {
+      printHostedJob(context.stdout, result, context.platform, context.appId);
+    }
+    return;
+  }
+  if (result.status !== "completed") {
+    if (parsed.options.json === true) {
+      context.stdout.log(JSON.stringify({ plan, intent: preview.intent, job: result }, null, 2));
+    }
+    throw new Error(`hosted security job ${result.jobId} ended ${result.status}${result.errorCode ? `: ${result.errorCode}` : ""}`);
+  }
+  const report = await getHostedSecurityReport({ ...context, jobId: result.jobId });
+  if (parsed.options.json === true) {
+    context.stdout.log(JSON.stringify({ plan, intent: preview.intent, job: result, report }, null, 2));
+  } else {
+    printHostedReport(context.stdout, report);
+  }
+  enforceHostedReportGate(report, parsed, context.stdout, parsed.options.json !== true);
+}
+async function runLocalSecurityCommand(parsed, dependencies) {
+  if (parsed.options.source === true) {
+    throw new Error("--source requires a source id; run security sources first");
+  }
+  assertArgs(parsed, [
+    "config",
+    "env",
+    "out",
+    "profile",
+    "max-hunt-tasks",
+    "run-id",
+    "platform",
+    "self",
+    "ack-redacted-source",
+    "open",
+    "fail-on",
+    "fail-on-candidates",
+    "allow-incomplete"
+  ], 3);
+  const configPath = stringOpt(parsed.options.config) ?? "odla.config.mjs";
+  const selfAudit = parsed.options.self === true;
+  const open = parsed.options.open === false ? false : parsed.options.open === true ? true : void 0;
+  const platform = stringOpt(parsed.options.platform);
+  const doFetch = dependencies.fetch ?? fetch;
+  const out = dependencies.stdout ?? console;
+  const result = await runHostedSecurity({
+    configPath,
+    selfAudit,
+    target: parsed.positionals[2],
+    out: stringOpt(parsed.options.out),
+    env: stringOpt(parsed.options.env),
+    profile: securityProfile(stringOpt(parsed.options.profile)),
+    maxHuntTasks: numberOpt(parsed.options["max-hunt-tasks"], "--max-hunt-tasks"),
+    runId: stringOpt(parsed.options["run-id"]),
+    platform,
+    sourceDisclosureAck: parsed.options["ack-redacted-source"] === true ? "redacted" : void 0,
+    fetch: doFetch,
+    stdout: out,
+    getToken: async (request) => {
+      if (request.scope === "platform:security:self") {
+        return getScopedPlatformToken({
+          platform: request.platform,
+          scope: request.scope,
+          open,
+          fetch: doFetch,
+          stdout: out,
+          openApprovalUrl: dependencies.openUrl
+        });
+      }
+      const cfg = await loadProjectConfig(configPath);
+      if (platformAudience(cfg.platformUrl) !== platformAudience(request.platform)) {
+        throw new Error("--platform cannot reuse a project developer token from another platform; update odla.config.mjs and authenticate there");
+      }
+      return getDeveloperToken(
+        cfg,
+        { configPath, open, openApprovalUrl: dependencies.openUrl },
+        doFetch,
+        out
+      );
+    }
+  });
+  enforceLocalGate(result.report, parsed);
+}
+function enforceLocalGate(report, parsed) {
+  const failOn = severityOpt(stringOpt(parsed.options["fail-on"]) ?? "high", "--fail-on");
+  const candidateValue = parsed.options["fail-on-candidates"];
+  const failOnCandidates = candidateValue === false ? void 0 : severityOpt(stringOpt(candidateValue) ?? "critical", "--fail-on-candidates");
+  const confirmed = findingsAtOrAbove(report, failOn);
+  const leads = failOnCandidates ? findingsAtOrAbove(report, failOnCandidates, true).filter((finding) => finding.disposition !== "confirmed") : [];
+  const incomplete = report.coverageStatus === "incomplete" && parsed.options["allow-incomplete"] !== true;
+  if (confirmed.length || leads.length || incomplete) {
+    throw new Error(`hosted security gate failed: ${confirmed.length} confirmed >= ${failOn}; ${leads.length} leads >= ${failOnCandidates ?? "disabled"}${incomplete ? "; coverage incomplete" : ""}`);
+  }
+}
+function severityOpt(value, flag) {
+  if (["informational", "low", "medium", "high", "critical"].includes(value)) {
+    return value;
+  }
+  throw new Error(`${flag} must be informational, low, medium, high, or critical`);
+}
+
+// src/security-command.ts
+async function securityCommand(parsed, dependencies) {
+  const sub = parsed.positionals[1];
+  if (sub === "github") {
+    await githubSecurityCommand(parsed, dependencies);
+    return;
+  }
+  if (sub === "plan") {
+    assertArgs(parsed, ["config", "env", "platform", "open", "json"], 2);
+    const context = await hostedSecurityContext(parsed, dependencies);
+    const plan = await getHostedSecurityPlan(context);
+    if (parsed.options.json === true) context.stdout.log(JSON.stringify(plan, null, 2));
+    else printHostedSecurityPlan(context.stdout, plan, context.appId);
+    return;
+  }
+  if (sub === "sources") {
+    await listSecuritySources(parsed, dependencies);
+    return;
+  }
+  if (sub === "status") {
+    await securityStatus(parsed, dependencies);
+    return;
+  }
+  if (sub === "report") {
+    assertArgs(parsed, ["config", "env", "platform", "open", "json"], 3);
+    const jobId = requiredSecurityPositional(parsed, 2, "job id");
+    const context = await hostedSecurityContext(parsed, dependencies);
+    const report = await getHostedSecurityReport({ ...context, jobId });
+    if (parsed.options.json === true) context.stdout.log(JSON.stringify(report, null, 2));
+    else printHostedReport(context.stdout, report);
+    return;
+  }
+  if (sub !== "run") {
+    throw new Error('unknown security command. Try "odla-ai security plan", "security sources", or "security run".');
+  }
+  const sourceId = stringOpt(parsed.options.source);
+  if (sourceId) await runSourceSecurityCommand(parsed, dependencies, sourceId);
+  else await runLocalSecurityCommand(parsed, dependencies);
+}
+async function githubSecurityCommand(parsed, dependencies) {
+  const action = parsed.positionals[2];
+  if (action === "disconnect") {
+    assertArgs(parsed, ["config", "env", "platform", "source", "open", "yes"], 3);
+    const context2 = await hostedSecurityContext(parsed, dependencies);
+    const sourceId = requiredString(parsed.options.source, "--source");
+    const confirmed = parsed.options.yes === true || await interactiveConfirmation(
+      `Disconnect GitHub security source ${sourceId} from ${context2.appId}/${context2.env}?`,
+      dependencies
+    );
+    if (!confirmed) {
+      throw new Error("GitHub source disconnect cancelled; pass --yes in a non-interactive shell");
+    }
+    await disconnectGitHubSecuritySource({ ...context2, sourceId });
+    context2.stdout.log(`github: disconnected ${sourceId} from ${context2.appId}/${context2.env}`);
+    return;
+  }
+  if (action !== "connect") {
+    throw new Error('unknown security github command. Try "odla-ai security github connect".');
+  }
+  assertArgs(parsed, ["config", "env", "platform", "repo", "open"], 3);
+  const context = await hostedSecurityContext(parsed, dependencies);
+  const repository = stringOpt(parsed.options.repo) ?? await inferGitHubRepository(process.cwd(), dependencies.readGitOrigin);
+  const connection = await connectGitHubSecuritySource({
+    ...context,
+    repository,
+    open: parsed.options.open !== false,
+    openInstallUrl: dependencies.openUrl ?? openUrl,
+    wait: dependencies.pollWait,
+    stdout: context.stdout
+  });
+  context.stdout.log(`github: connected ${connection.repository ?? repository} (${connection.sourceId ?? "source pending"})`);
+  context.stdout.log("github: odla.ai stores the installation; no PAT or GitHub token is written locally");
+}
+async function listSecuritySources(parsed, dependencies) {
+  assertArgs(parsed, ["config", "env", "platform", "open", "json"], 2);
+  const context = await hostedSecurityContext(parsed, dependencies);
+  const [plan, sources] = await Promise.all([
+    getHostedSecurityPlan(context),
+    listGitHubSecuritySources(context)
+  ]);
+  if (parsed.options.json === true) {
+    context.stdout.log(JSON.stringify({ plan, sources }, null, 2));
+    return;
+  }
+  printHostedSecurityPlan(context.stdout, plan, context.appId);
+  if (!sources.length) {
+    context.stdout.log(`No GitHub security sources connected for ${context.appId}/${context.env}.`);
+    return;
+  }
+  context.stdout.log(`GitHub security sources for ${context.appId}/${context.env}
+source	repository	default ref	status`);
+  for (const source of sources) {
+    context.stdout.log(`${source.sourceId}	${source.repository}	${source.defaultBranch}	${source.status}`);
+  }
+}
+async function securityStatus(parsed, dependencies) {
+  assertArgs(parsed, ["config", "env", "platform", "open", "json", "follow"], 3);
+  const jobId = requiredSecurityPositional(parsed, 2, "job id");
+  const context = await hostedSecurityContext(parsed, dependencies);
+  const job = parsed.options.follow === true ? await followHostedSecurityJob({
+    ...context,
+    jobId,
+    wait: dependencies.pollWait,
+    onUpdate: parsed.options.json === true ? void 0 : (value) => printHostedJob(context.stdout, value, context.platform, context.appId)
+  }) : await getHostedSecurityJob({ ...context, jobId });
+  if (parsed.options.json === true) context.stdout.log(JSON.stringify(job, null, 2));
+  else if (parsed.options.follow !== true) {
+    printHostedJob(context.stdout, job, context.platform, context.appId);
+  }
+}
+
 // src/cli.ts
-async function runCli(argv = process.argv.slice(2)) {
+async function runCli(argv = process.argv.slice(2), dependencies = {}) {
   const parsed = parseArgv(argv);
   const command = parsed.positionals[0] ?? "help";
   if (command === "version" || command === "-v" || parsed.options.version === true) {
@@ -2141,7 +3040,15 @@ async function runCli(argv = process.argv.slice(2)) {
     return;
   }
   if (command === "init") {
-    assertArgs(parsed, ["app-id", "name", "config", "env", "services", "ai-provider", "force"], 1);
+    assertArgs(parsed, [
+      "app-id",
+      "name",
+      "config",
+      "env",
+      "services",
+      "ai-provider",
+      "force"
+    ], 1);
     initProject({
       appId: requiredString(parsed.options["app-id"], "--app-id"),
       name: requiredString(parsed.options.name, "--name"),
@@ -2164,149 +3071,15 @@ async function runCli(argv = process.argv.slice(2)) {
     return;
   }
   if (command === "admin") {
-    const area = parsed.positionals[1];
-    const action = parsed.positionals[2];
-    const credentialSet = action === "credential" && parsed.positionals[3] === "set";
-    const credentials = action === "credentials";
-    const models = action === "models";
-    const usage = action === "usage";
-    const audit = action === "audit";
-    if (area !== "ai" || action !== "show" && action !== "set" && !credentialSet && !credentials && !models && !usage && !audit) {
-      throw new Error('unknown admin command. Try "odla-ai admin ai show".');
-    }
-    assertArgs(parsed, [
-      "platform",
-      "json",
-      "open",
-      "provider",
-      "model",
-      "enabled",
-      "max-input-bytes",
-      "max-output-tokens",
-      "max-calls-per-run",
-      "from-env",
-      "stdin",
-      "discovery-provider",
-      "discovery-model",
-      "validation-provider",
-      "validation-model",
-      "app-id",
-      "env",
-      "run-id",
-      "limit"
-    ], credentialSet ? 5 : action === "set" ? 4 : 3);
-    await adminAi({
-      action: credentialSet ? "credential-set" : credentials ? "credentials" : models ? "models" : usage ? "usage" : audit ? "audit" : action,
-      purpose: action === "set" ? parsed.positionals[3] : void 0,
-      provider: stringOpt(parsed.options.provider),
-      model: stringOpt(parsed.options.model),
-      enabled: boolOpt(parsed.options.enabled),
-      maxInputBytes: numberOpt(parsed.options["max-input-bytes"], "--max-input-bytes"),
-      maxOutputTokens: numberOpt(parsed.options["max-output-tokens"], "--max-output-tokens"),
-      maxCallsPerRun: numberOpt(parsed.options["max-calls-per-run"], "--max-calls-per-run"),
-      platform: stringOpt(parsed.options.platform),
-      json: parsed.options.json === true,
-      open: parsed.options.open === false ? false : parsed.options.open === true ? true : void 0,
-      credentialProvider: credentialSet ? parsed.positionals[4] : void 0,
-      fromEnv: stringOpt(parsed.options["from-env"]),
-      stdin: parsed.options.stdin === true,
-      discoveryProvider: stringOpt(parsed.options["discovery-provider"]),
-      discoveryModel: stringOpt(parsed.options["discovery-model"]),
-      validationProvider: stringOpt(parsed.options["validation-provider"]),
-      validationModel: stringOpt(parsed.options["validation-model"]),
-      appId: stringOpt(parsed.options["app-id"]),
-      env: stringOpt(parsed.options.env),
-      runId: stringOpt(parsed.options["run-id"]),
-      limit: numberOpt(parsed.options.limit, "--limit")
-    });
+    await adminCommand(parsed);
     return;
   }
   if (command === "security") {
-    const sub = parsed.positionals[1];
-    if (sub !== "run") throw new Error('unknown security command. Try "odla-ai security run".');
-    assertArgs(parsed, [
-      "config",
-      "env",
-      "out",
-      "profile",
-      "max-hunt-tasks",
-      "run-id",
-      "platform",
-      "self",
-      "ack-redacted-source",
-      "open",
-      "fail-on",
-      "fail-on-candidates",
-      "allow-incomplete"
-    ], 3);
-    const configPath = stringOpt(parsed.options.config) ?? "odla.config.mjs";
-    const selfAudit = parsed.options.self === true;
-    const open = parsed.options.open === false ? false : parsed.options.open === true ? true : void 0;
-    const platform = stringOpt(parsed.options.platform);
-    const result = await runHostedSecurity({
-      configPath,
-      selfAudit,
-      target: parsed.positionals[2],
-      out: stringOpt(parsed.options.out),
-      env: stringOpt(parsed.options.env),
-      profile: securityProfile(stringOpt(parsed.options.profile)),
-      maxHuntTasks: numberOpt(parsed.options["max-hunt-tasks"], "--max-hunt-tasks"),
-      runId: stringOpt(parsed.options["run-id"]),
-      platform,
-      sourceDisclosureAck: parsed.options["ack-redacted-source"] === true ? "redacted" : void 0,
-      getToken: async (request) => {
-        if (request.scope === "platform:security:self") {
-          return getScopedPlatformToken({ platform: request.platform, scope: request.scope, open });
-        }
-        const cfg = await loadProjectConfig(configPath);
-        if (platformAudience(cfg.platformUrl) !== platformAudience(request.platform)) {
-          throw new Error("--platform cannot reuse a project developer token from another platform; update odla.config.mjs and authenticate there");
-        }
-        return getDeveloperToken(cfg, { configPath, open }, fetch, console);
-      }
-    });
-    const failOn = severityOpt(stringOpt(parsed.options["fail-on"]) ?? "high", "--fail-on");
-    const candidateValue = parsed.options["fail-on-candidates"];
-    const failOnCandidates = candidateValue === false ? void 0 : severityOpt(stringOpt(candidateValue) ?? "critical", "--fail-on-candidates");
-    const confirmed = findingsAtOrAbove(result.report, failOn);
-    const leads = failOnCandidates ? findingsAtOrAbove(result.report, failOnCandidates, true).filter((finding) => finding.disposition !== "confirmed") : [];
-    const incomplete = result.report.coverageStatus === "incomplete" && parsed.options["allow-incomplete"] !== true;
-    if (confirmed.length || leads.length || incomplete) {
-      throw new Error(`hosted security gate failed: ${confirmed.length} confirmed >= ${failOn}; ${leads.length} leads >= ${failOnCandidates ?? "disabled"}${incomplete ? "; coverage incomplete" : ""}`);
-    }
+    await securityCommand(parsed, dependencies);
     return;
   }
   if (command === "provision") {
-    assertArgs(
-      parsed,
-      [
-        "config",
-        "dry-run",
-        "rotate-keys",
-        "rotate-o11y-token",
-        "push-secrets",
-        "write-credentials",
-        "write-dev-vars",
-        "token",
-        "open",
-        "yes"
-      ],
-      1
-    );
-    const writeDevVars2 = parsed.options["write-dev-vars"];
-    const opts = {
-      configPath: stringOpt(parsed.options.config) ?? "odla.config.mjs",
-      dryRun: parsed.options["dry-run"] === true,
-      rotateKeys: parsed.options["rotate-keys"] === true,
-      rotateO11yToken: parsed.options["rotate-o11y-token"] === true,
-      pushSecrets: parsed.options["push-secrets"] === true,
-      writeCredentials: parsed.options["write-credentials"] !== false,
-      writeDevVars: typeof writeDevVars2 === "string" ? writeDevVars2 : writeDevVars2 === true,
-      token: stringOpt(parsed.options.token),
-      open: parsed.options.open === false ? false : parsed.options.open === true ? true : void 0,
-      yes: parsed.options.yes === true
-    };
-    await provision(opts);
+    await provisionCommand(parsed);
     return;
   }
   if (command === "smoke") {
@@ -2332,7 +3105,9 @@ async function runCli(argv = process.argv.slice(2)) {
   }
   if (command === "skill") {
     const sub = parsed.positionals[1];
-    if (sub !== "install") throw new Error(`unknown skill subcommand "${sub ?? ""}". Try "odla-ai skill install".`);
+    if (sub !== "install") {
+      throw new Error(`unknown skill subcommand "${sub ?? ""}". Try "odla-ai skill install".`);
+    }
     assertArgs(parsed, ["dir", "global", "force", "agent", "harness"], 2);
     installSkill({
       dir: stringOpt(parsed.options.dir),
@@ -2344,7 +3119,9 @@ async function runCli(argv = process.argv.slice(2)) {
   }
   if (command === "secrets") {
     const sub = parsed.positionals[1];
-    if (sub !== "push") throw new Error(`unknown secrets subcommand "${sub ?? ""}". Try "odla-ai secrets push --env dev".`);
+    if (sub !== "push") {
+      throw new Error(`unknown secrets subcommand "${sub ?? ""}". Try "odla-ai secrets push --env dev".`);
+    }
     assertArgs(parsed, ["config", "env", "dry-run", "yes"], 2);
     await secretsPush({
       configPath: stringOpt(parsed.options.config) ?? "odla.config.mjs",
@@ -2356,29 +3133,33 @@ async function runCli(argv = process.argv.slice(2)) {
   }
   throw new Error(`unknown command "${command}". Run "odla-ai help".`);
 }
-function securityProfile(value) {
-  if (value === void 0) return void 0;
-  if (value === "odla" || value === "cloudflare-app" || value === "generic") return value;
-  throw new Error("--profile must be odla, cloudflare-app, or generic");
-}
-function severityOpt(value, flag) {
-  if (["informational", "low", "medium", "high", "critical"].includes(value)) return value;
-  throw new Error(`${flag} must be informational, low, medium, high, or critical`);
-}
-function harnessList(parsed) {
-  const selected = [
-    ...harnessOption(parsed.options.agent, "--agent"),
-    ...harnessOption(parsed.options.harness, "--harness")
-  ];
-  return selected.length ? selected : ["all"];
-}
-function harnessOption(value, flag) {
-  if (value === void 0) return [];
-  if (typeof value === "boolean") throw new Error(`${flag} requires a harness name`);
-  const raw = Array.isArray(value) ? value : [value];
-  const parts = raw.flatMap((item) => item.split(","));
-  if (parts.some((item) => !item.trim())) throw new Error(`${flag} requires a harness name`);
-  return parts.map((item) => item.trim());
+async function provisionCommand(parsed) {
+  assertArgs(parsed, [
+    "config",
+    "dry-run",
+    "rotate-keys",
+    "rotate-o11y-token",
+    "push-secrets",
+    "write-credentials",
+    "write-dev-vars",
+    "token",
+    "open",
+    "yes"
+  ], 1);
+  const writeDevVars2 = parsed.options["write-dev-vars"];
+  const options = {
+    configPath: stringOpt(parsed.options.config) ?? "odla.config.mjs",
+    dryRun: parsed.options["dry-run"] === true,
+    rotateKeys: parsed.options["rotate-keys"] === true,
+    rotateO11yToken: parsed.options["rotate-o11y-token"] === true,
+    pushSecrets: parsed.options["push-secrets"] === true,
+    writeCredentials: parsed.options["write-credentials"] !== false,
+    writeDevVars: typeof writeDevVars2 === "string" ? writeDevVars2 : writeDevVars2 === true,
+    token: stringOpt(parsed.options.token),
+    open: parsed.options.open === false ? false : parsed.options.open === true ? true : void 0,
+    yes: parsed.options.yes === true
+  };
+  await provision(options);
 }
 
 export {
@@ -2393,9 +3174,22 @@ export {
   secretsPush,
   provision,
   runHostedSecurity,
+  connectGitHubSecuritySource,
+  listGitHubSecuritySources,
+  disconnectGitHubSecuritySource,
+  repositoryFromGitRemote,
+  inferGitHubRepository,
+  getHostedSecurityIntent,
+  getHostedSecurityPlan,
+  startHostedSecurityJob,
+  getHostedSecurityJob,
+  listHostedSecurityJobs,
+  followHostedSecurityJob,
+  getHostedSecurityReport,
+  isTerminalHostedSecurityStatus,
   AGENT_HARNESSES,
   installSkill,
   smoke,
   runCli
 };
-//# sourceMappingURL=chunk-643B2AKG.js.map
+//# sourceMappingURL=chunk-BHAEDEL2.js.map