@dalmia/calibrate-mcp 0.0.30 → 0.0.32

package/bin/mcp-server.js

@@ -1021,10 +1021,10 @@ function datetime(args) {
   const timeRegex = `${time2}(?:${opts.join("|")})`;
   return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
 }
-var cuid, cuid2, ulid, xid, ksuid, nanoid, duration, guid, uuid = (version) => {
-  if (!version)
+var cuid, cuid2, ulid, xid, ksuid, nanoid, duration, guid, uuid = (version2) => {
+  if (!version2)
     return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
-  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
+  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
 }, email, _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`, ipv4, ipv6, cidrv4, cidrv6, base64, base64url, httpProtocol, e164, dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`, date, string = (params) => {
   const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
   return new RegExp(`^${regex}$`);
@@ -1491,9 +1491,9 @@ class Doc {
 }
 
 // node_modules/zod/v4/core/versions.js
-var version;
+var version2;
 var init_versions = __esm(() => {
-  version = {
+  version2 = {
     major: 4,
     minor: 4,
     patch: 3
@@ -1793,7 +1793,7 @@ var init_schemas = __esm(() => {
     inst ?? (inst = {});
     inst._zod.def = def;
     inst._zod.bag = inst._zod.bag || {};
-    inst._zod.version = version;
+    inst._zod.version = version2;
     const checks = [...inst._zod.def.checks ?? []];
     if (inst._zod.traits.has("$ZodCheck")) {
       checks.unshift(inst);
@@ -8247,10 +8247,10 @@ var require_supports_color = __commonJS((exports, module) => {
       return 3;
     }
     if ("TERM_PROGRAM" in env) {
-      const version2 = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+      const version3 = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
       switch (env.TERM_PROGRAM) {
         case "iTerm.app":
-          return version2 >= 3 ? 3 : 2;
+          return version3 >= 3 ? 3 : 2;
         case "Apple_Terminal":
           return 2;
       }
@@ -22971,18 +22971,12 @@ var require_media_typer = __commonJS((exports) => {
     return string4;
   }
   function test(string4) {
-    if (!string4) {
-      throw new TypeError("argument string is required");
-    }
     if (typeof string4 !== "string") {
       throw new TypeError("argument string is required to be a string");
     }
     return TYPE_REGEXP.test(string4.toLowerCase());
   }
   function parse5(string4) {
-    if (!string4) {
-      throw new TypeError("argument string is required");
-    }
     if (typeof string4 !== "string") {
       throw new TypeError("argument string is required to be a string");
     }
@@ -32341,11 +32335,11 @@ function datetimeRegex(args) {
   regex = `${regex}(${opts.join("|")})`;
   return new RegExp(`^${regex}$`);
 }
-function isValidIP(ip, version2) {
-  if ((version2 === "v4" || !version2) && ipv4Regex.test(ip)) {
+function isValidIP(ip, version3) {
+  if ((version3 === "v4" || !version3) && ipv4Regex.test(ip)) {
     return true;
   }
-  if ((version2 === "v6" || !version2) && ipv6Regex.test(ip)) {
+  if ((version3 === "v6" || !version3) && ipv6Regex.test(ip)) {
     return true;
   }
   return false;
@@ -32372,11 +32366,11 @@ function isValidJWT2(jwt, alg) {
     return false;
   }
 }
-function isValidCidr(ip, version2) {
-  if ((version2 === "v4" || !version2) && ipv4CidrRegex.test(ip)) {
+function isValidCidr(ip, version3) {
+  if ((version3 === "v4" || !version3) && ipv4CidrRegex.test(ip)) {
     return true;
   }
-  if ((version2 === "v6" || !version2) && ipv6CidrRegex.test(ip)) {
+  if ((version3 === "v6" || !version3) && ipv6CidrRegex.test(ip)) {
     return true;
   }
   return false;
@@ -41433,7 +41427,12 @@ var require_fast_uri = __commonJS((exports, module) => {
   }
   function resolve(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-    const resolved = resolveComponent(parse6(baseURI, schemelessOptions), parse6(relativeURI, schemelessOptions), schemelessOptions, true);
+    const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
+    const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
+    if (baseMalformed || relativeMalformed) {
+      throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
+    }
+    const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
     schemelessOptions.skipEscape = true;
     return serialize(resolved, schemelessOptions);
   }
@@ -41559,6 +41558,8 @@ var require_fast_uri = __commonJS((exports, module) => {
     return uriTokens.join("");
   }
   var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
+  var AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
+  var AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
   function getParseError(parsed, matches) {
     if (matches[2] !== undefined && parsed.path && parsed.path[0] !== "/") {
       return 'URI path must start with "/" when authority is present.';
@@ -41588,6 +41589,25 @@ var require_fast_uri = __commonJS((exports, module) => {
         uri = "//" + uri;
       }
     }
+    const authorityMatch = uri.match(AUTHORITY_PREFIX);
+    if (authorityMatch !== null && authorityMatch[1].indexOf("\\") !== -1) {
+      parsed.error = "URI authority must not contain a literal backslash.";
+      malformedAuthorityOrPort = true;
+    }
+    const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION);
+    if (introducerMatch !== null) {
+      const region = introducerMatch[1];
+      const normalizedRegion = region.replace(/[\t\n\r]/g, "");
+      if (normalizedRegion.length >= 2) {
+        if (normalizedRegion.slice(0, 2) !== "//") {
+          parsed.error = parsed.error || "URI authority must not contain a literal backslash.";
+          malformedAuthorityOrPort = true;
+        } else if (region.length !== normalizedRegion.length) {
+          parsed.error = parsed.error || "URI authority introducer must not contain whitespace.";
+          malformedAuthorityOrPort = true;
+        }
+      }
+    }
     const matches = uri.match(URI_PARSE);
     if (matches) {
       parsed.scheme = matches[1] === undefined ? undefined : matches[1].toLowerCase();
@@ -51392,9 +51412,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "0.1.0",
-    sdkVersion: "0.0.30",
+    sdkVersion: "0.0.32",
     genVersion: "2.915.1",
-    userAgent: "speakeasy-sdk/mcp-typescript 0.0.30 2.915.1 0.1.0 @dalmia/calibrate-mcp"
+    userAgent: "speakeasy-sdk/mcp-typescript 0.0.32 2.915.1 0.1.0 @dalmia/calibrate-mcp"
   };
 });
 
@@ -53374,6 +53394,7 @@ var init_agentsummary = __esm(() => {
   ]).describe("- `agent`: built inside Calibrate\n- `connection`: your existing agent connected to Calibrate");
   AgentSummary$zodSchema = object({
     connection_verified: boolean2().nullable().optional().describe("Whether the agent's connection has been verified, for a `type=connection` agent"),
+    has_default_inputs: boolean2().describe("Whether the agent has custom request fields configured"),
     name: string2().describe("Name of the agent"),
     type: AgentSummaryType$zodSchema.describe("- `agent`: built inside Calibrate\n- `connection`: your existing agent connected to Calibrate"),
     updated_at: string2().describe("When the agent was last updated (ISO 8601 UTC)"),
@@ -54409,6 +54430,7 @@ var init_testcaseresult = __esm(() => {
   init_testoutput();
   TestCaseResult$zodSchema = object({
     cost: number2().nullable().optional().describe("Cost of this case (USD)"),
+    inputs: record(string2(), any()).nullable().optional().describe("Extra request fields sent to the agent for this case, the agent's `default_inputs` with this case's overrides applied"),
     judge_results: array(JudgeResult$zodSchema).nullable().optional().describe("One verdict for each evaluator"),
     latency_ms: number2().nullable().optional().describe("How long the agent took to respond, in milliseconds"),
     name: string2().nullable().optional().describe("Name of the test"),
@@ -54488,7 +54510,8 @@ var init_benchmarkstatusresponse = __esm(() => {
     model_results: array(ModelResult$zodSchema).nullable().optional().describe("Results for each model"),
     share_token: string2().nullable().optional().describe("Token for building the public share URL"),
     status: TaskStatus$zodSchema,
-    task_id: string2().describe("Benchmark run job ID")
+    task_id: string2().describe("Benchmark run job ID"),
+    test_uuids: array(string2()).nullable().optional().describe("IDs of the tests this benchmark executed, in run order")
   });
 });
 
@@ -54651,6 +54674,7 @@ var init_testrunstatusresponse = __esm(() => {
     share_token: string2().nullable().optional().describe("Token for building the public share URL"),
     status: TaskStatus$zodSchema,
     task_id: string2().describe("Test run job ID"),
+    test_uuids: array(string2()).nullable().optional().describe("IDs of the tests this run executed, in run order"),
     total_tests: int().nullable().optional().describe("Total number of test cases"),
     total_tokens: record(string2(), any()).nullable().optional().describe("Aggregated token usage as `{mean, min, max, count}`")
   });
@@ -56207,6 +56231,7 @@ var init_annotationtaskresponse = __esm(() => {
     created_at: string2().describe("When the task was created (ISO 8601 UTC)"),
     description: string2().nullable().optional().describe("The task's description"),
     evaluators: array(record(string2(), any())).optional().describe("The evaluators linked to this task, in display order. Fetching one task by ID enriches each with its live version's rubric. Listing tasks returns lightweight metadata (uuid, name, type, position) only"),
+    has_agreement: boolean2().default(false).describe("Whether the task has at least one comparable human-vs-human or human-vs-evaluator pair, computed over all time"),
     item_count: int().nullable().optional().describe("Number of items in the task"),
     items: array(record(string2(), any())).optional().describe("The task's items, each with its agreement stats. You get these when you fetch one task by ID, not when you list tasks"),
     jobs: array(record(string2(), any())).optional().describe("The task's labelling jobs. You get these when you fetch one task by ID, not when you list tasks"),
@@ -56383,7 +56408,7 @@ var init_taskagreementresponse = __esm(() => {
   TaskAgreementResponse$zodSchema = collectExtraKeys(object({
     bucket: string2().describe("Time bucket used for the trend series"),
     days: int().describe("Length of the trailing window in days"),
-    evaluators: array(record(string2(), any())).describe("Agreement between each evaluator and the annotators, one entry per linked evaluator"),
+    evaluators: array(record(string2(), any())).describe("Agreement between each evaluator and the annotators, plus that evaluator's own results, one entry per linked evaluator"),
     human_human: HumanAgreementBlock$zodSchema,
     task_id: string2().describe("ID of the task")
   }).catchall(any()), "AdditionalProperties", true);
@@ -58174,6 +58199,7 @@ var init_bulktestitem = __esm(() => {
   BulkTestItem$zodSchema = object({
     conversation_history: array(ChatMessage$zodSchema).describe("Ordered messages ending at the user turn the agent should answer"),
     evaluators: array(RoutersTestsEvaluatorRef$zodSchema).nullable().optional().describe("Evaluators to link. Used by `response` and `conversation` tests"),
+    inputs: record(string2(), any()).nullable().optional().describe("Extra request fields for this test, overriding the agent's `default_inputs` per key"),
     name: string2().describe("Name of the test, unique within the workspace and within the batch"),
     tool_calls: array(ExpectedToolCall$zodSchema).nullable().optional().describe("Expected tool calls. **Required for `tool_call` batches**")
   });
@@ -58972,7 +58998,7 @@ fields to change (name, config). Returns the updated test. Fails with
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "CalibrateMcp",
-    version: "0.0.30"
+    version: "0.0.32"
   });
   const getClient = deps.getSDK || (() => new CalibrateMcpCore({
     security: deps.security,
@@ -60199,7 +60225,7 @@ http_headers = { "api-key-auth" = "YOUR_API_KEY_AUTH" }`;
         <h1>Instructions</h1>
         <p>One-click installation for Claude Desktop users</p>
         <div class="instruction-item">
-          <a href="https://github.com/dalmia/calibrate-mcp/releases/download/v0.0.30/mcp-server.mcpb" download="mcp-server.mcpb" class="action-button header-action" style="display: inline-flex; margin-bottom: 16px;">
+          <a href="https://github.com/dalmia/calibrate-mcp/releases/download/v0.0.32/mcp-server.mcpb" download="mcp-server.mcpb" class="action-button header-action" style="display: inline-flex; margin-bottom: 16px;">
             \uD83D\uDCE5 Download MCP Bundle
           </a>
         </div>
@@ -60810,23 +60836,8 @@ var init_impl2 = __esm(() => {
 });
 
 // node_modules/@stricli/core/dist/index.js
-var TRUTHY_VALUES = /* @__PURE__ */ new Set(["true", "t", "yes", "y", "on", "1", ""]);
-var FALSY_VALUES = /* @__PURE__ */ new Set(["false", "f", "no", "n", "off", "0"]);
-var looseBooleanParser = (input) => {
-  const value = input.toLowerCase();
-  if (TRUTHY_VALUES.has(value)) {
-    return true;
-  }
-  if (FALSY_VALUES.has(value)) {
-    return false;
-  }
-  throw new SyntaxError(`Cannot convert ${input} to a boolean`);
-};
-function checkEnvironmentVariable(process2, varName) {
-  const value = process2.env?.[varName];
-  return typeof value === "string" && looseBooleanParser(value);
-}
 var ExitCode = {
+  IntegrationError: -10,
   UnknownCommand: -5,
   InvalidArgument: -4,
   ContextLoadError: -3,
@@ -60995,6 +61006,18 @@ async function allSettledOrElse(values) {
   }
   return { status: "fulfilled", value: grouped.fulfilled?.map((result) => result.value) ?? [] };
 }
+var TRUTHY_VALUES = /* @__PURE__ */ new Set(["true", "t", "yes", "y", "on", "1", ""]);
+var FALSY_VALUES = /* @__PURE__ */ new Set(["false", "f", "no", "n", "off", "0"]);
+var looseBooleanParser = (input) => {
+  const value = input.toLowerCase();
+  if (TRUTHY_VALUES.has(value)) {
+    return true;
+  }
+  if (FALSY_VALUES.has(value)) {
+    return false;
+  }
+  throw new SyntaxError(`Cannot convert ${input} to a boolean`);
+};
 var numberParser = (input) => {
   const value = Number(input);
   if (Number.isNaN(value)) {
@@ -61013,6 +61036,11 @@ function formatMessageForArgumentScannerError(error, formatter) {
   }
   return error.message;
 }
+function resolveAllowedNegationForFlags(flags) {
+  return Object.fromEntries(Object.entries(flags).map(([internalFlagName, flag]) => {
+    return [internalFlagName, flag.kind === "boolean" && flag.withNegated !== false];
+  }));
+}
 function resolveAliases(flags, aliases, scannerCaseStyle) {
   return Object.fromEntries(Object.entries(aliases).map(([alias, internalFlagName_]) => {
     const internalFlagName = internalFlagName_;
@@ -61156,7 +61184,7 @@ function undoNegation(flagName) {
     return firstLower + flagName.slice(3);
   }
 }
-function findInternalFlagMatch(externalFlagName, flags, config) {
+function findInternalFlagMatch(externalFlagName, flags, allowsNegation, config) {
   const internalFlagName = externalFlagName;
   let flag = flags[internalFlagName];
   let foundFlagWithNegatedFalse;
@@ -61165,9 +61193,9 @@ function findInternalFlagMatch(externalFlagName, flags, config) {
     const internalWithoutNegation = undoNegation(internalFlagName);
     if (internalWithoutNegation) {
       flag = flags[internalWithoutNegation];
-      if (flag && flag.kind == "boolean") {
-        if (flag.withNegated !== false) {
-          return { namedFlag: [internalWithoutNegation, flag], negated: true };
+      if (flag) {
+        if (allowsNegation[internalWithoutNegation]) {
+          return [internalWithoutNegation, flag, true];
         } else {
           foundFlagWithNegatedFalse = internalWithoutNegation;
           flag = undefined;
@@ -61179,14 +61207,14 @@ function findInternalFlagMatch(externalFlagName, flags, config) {
   if (config.caseStyle === "allow-kebab-for-camel" && !flag) {
     flag = flags[camelCaseFlagName];
     if (flag) {
-      return { namedFlag: [camelCaseFlagName, flag] };
+      return [camelCaseFlagName, flag];
     }
     const camelCaseWithoutNegation = undoNegation(camelCaseFlagName);
     if (camelCaseWithoutNegation) {
       flag = flags[camelCaseWithoutNegation];
-      if (flag && flag.kind == "boolean") {
-        if (flag.withNegated !== false) {
-          return { namedFlag: [camelCaseWithoutNegation, flag], negated: true };
+      if (flag) {
+        if (allowsNegation[camelCaseWithoutNegation]) {
+          return [camelCaseWithoutNegation, flag, true];
         } else {
           foundFlagWithNegatedFalse = camelCaseWithoutNegation;
           foundFlagWithNegatedFalseFromKebabConversion = true;
@@ -61213,17 +61241,17 @@ function findInternalFlagMatch(externalFlagName, flags, config) {
     const corrections = filterClosestAlternatives(internalFlagName, Object.keys(flags), config.distanceOptions);
     throw new FlagNotFoundError(externalFlagName, corrections);
   }
-  return { namedFlag: [internalFlagName, flag] };
+  return [internalFlagName, flag];
 }
 function isNiladic(namedFlagWithNegation) {
-  if (namedFlagWithNegation.namedFlag[1].kind === "boolean" || namedFlagWithNegation.namedFlag[1].kind === "counter") {
+  if (namedFlagWithNegation[1].kind === "boolean" || namedFlagWithNegation[1].kind === "counter") {
     return true;
   }
   return false;
 }
 var FLAG_SHORTHAND_PATTERN = /^-([a-z]+)$/i;
 var FLAG_NAME_PATTERN = /^--([a-z][a-z-.\d_]+)$/i;
-function findFlagsByArgument(arg, flags, resolvedAliases, config) {
+function findFlagsByArgument(arg, flags, allowsNegation, resolvedAliases, config) {
   const shorthandMatch = FLAG_SHORTHAND_PATTERN.exec(arg);
   if (shorthandMatch) {
     const batch = shorthandMatch[1];
@@ -61233,13 +61261,13 @@ function findFlagsByArgument(arg, flags, resolvedAliases, config) {
       if (!namedFlag) {
         throw new AliasNotFoundError(aliasName);
       }
-      return { namedFlag };
+      return namedFlag;
     });
   }
   const flagNameMatch = FLAG_NAME_PATTERN.exec(arg);
   if (flagNameMatch) {
     const externalFlagName = flagNameMatch[1];
-    return [findInternalFlagMatch(externalFlagName, flags, config)];
+    return [findInternalFlagMatch(externalFlagName, flags, allowsNegation, config)];
   }
   return [];
 }
@@ -61254,16 +61282,16 @@ var InvalidNegatedFlagSyntaxError = class extends ArgumentScannerError {
     this.valueText = valueText;
   }
 };
-function findFlagByArgumentWithInput(arg, flags, resolvedAliases, config) {
+function findFlagByArgumentWithInput(arg, flags, allowsNegation, resolvedAliases, config) {
   const flagsNameMatch = FLAG_NAME_VALUE_PATTERN.exec(arg);
   if (flagsNameMatch) {
     const externalFlagName = flagsNameMatch[1];
-    const { namedFlag: flagMatch, negated } = findInternalFlagMatch(externalFlagName, flags, config);
+    const namedFlag = findInternalFlagMatch(externalFlagName, flags, allowsNegation, config);
     const valueText = flagsNameMatch[2];
-    if (negated) {
+    if (namedFlag[2]) {
       throw new InvalidNegatedFlagSyntaxError(externalFlagName, valueText);
     }
-    return [flagMatch, valueText];
+    return [namedFlag, valueText];
   }
   const aliasValueMatch = ALIAS_VALUE_PATTERN.exec(arg);
   if (aliasValueMatch) {
@@ -61395,6 +61423,7 @@ function isFlagSatisfiedByInputs(flags, flagInputs, key) {
 }
 function buildArgumentScanner(parameters, config) {
   const { flags = {}, aliases = {}, positional = { kind: "tuple", parameters: [] } } = parameters;
+  const allowsNegation = resolveAllowedNegationForFlags(flags);
   const resolvedAliases = resolveAliases(flags, aliases, config.caseStyle);
   const positionalInputs = [];
   const flagInputs = /* @__PURE__ */ new Map;
@@ -61417,7 +61446,7 @@ function buildArgumentScanner(parameters, config) {
         return;
       }
       if (!treatInputsAsArguments) {
-        const flagInput = findFlagByArgumentWithInput(input, flags, resolvedAliases, config);
+        const flagInput = findFlagByArgumentWithInput(input, flags, allowsNegation, resolvedAliases, config);
         if (flagInput) {
           if (activeFlag) {
             if (activeFlag[1].kind === "parsed" && activeFlag[1].inferEmpty) {
@@ -61432,7 +61461,7 @@ function buildArgumentScanner(parameters, config) {
           storeInput(flagInputs, config.caseStyle, ...flagInput);
           return;
         }
-        const nextFlags = findFlagsByArgument(input, flags, resolvedAliases, config);
+        const nextFlags = findFlagsByArgument(input, flags, allowsNegation, resolvedAliases, config);
         if (nextFlags.length > 0) {
           if (activeFlag) {
             if (activeFlag[1].kind === "parsed" && activeFlag[1].inferEmpty) {
@@ -61440,24 +61469,24 @@ function buildArgumentScanner(parameters, config) {
               activeFlag = undefined;
             } else {
               const externalFlagName = asExternal(activeFlag[0], config.caseStyle);
-              const nextFlagName = asExternal(nextFlags[0].namedFlag[0], config.caseStyle);
+              const nextFlagName = asExternal(nextFlags[0][0], config.caseStyle);
               throw new UnsatisfiedFlagError(externalFlagName, nextFlagName);
             }
           }
           if (nextFlags.every(isNiladic)) {
             for (const nextFlag of nextFlags) {
-              if (nextFlag.namedFlag[1].kind === "boolean") {
-                storeInput(flagInputs, config.caseStyle, nextFlag.namedFlag, nextFlag.negated ? "false" : "true");
+              if (nextFlag[1].kind === "boolean") {
+                storeInput(flagInputs, config.caseStyle, nextFlag, nextFlag[2] ? "false" : "true");
               } else {
-                storeInput(flagInputs, config.caseStyle, nextFlag.namedFlag, "1");
+                storeInput(flagInputs, config.caseStyle, nextFlag, "1");
               }
             }
           } else if (nextFlags.length > 1) {
             const nextFlagExpectingArg = nextFlags.find((nextFlag) => !isNiladic(nextFlag));
-            const externalFlagName = asExternal(nextFlagExpectingArg.namedFlag[0], config.caseStyle);
+            const externalFlagName = asExternal(nextFlagExpectingArg[0], config.caseStyle);
             throw new UnsatisfiedFlagError(externalFlagName);
           } else {
-            activeFlag = nextFlags[0].namedFlag;
+            activeFlag = nextFlags[0];
           }
           return;
         }
@@ -61546,7 +61575,7 @@ function buildArgumentScanner(parameters, config) {
       const parsedFlags = Object.fromEntries(flagEntriesResult.value);
       return { success: true, arguments: [parsedFlags, ...positionalValuesResult.value] };
     },
-    proposeCompletions: async ({ partial, completionConfig, text, context, includeVersionFlag }) => {
+    proposeCompletions: async ({ partial, completionConfig, text, context }) => {
       if (activeFlag) {
         return proposeFlagCompletionsForPartialInput(activeFlag[1], context, partial);
       }
@@ -61568,12 +61597,6 @@ function buildArgumentScanner(parameters, config) {
             }
           } else if (shorthandMatch) {
             const partialAliases = Array.from(shorthandMatch[1]);
-            if (partialAliases.includes("h")) {
-              return [];
-            }
-            if (includeVersionFlag && partialAliases.includes("v")) {
-              return [];
-            }
             const flagInputsIncludingPartial = new Map(flagInputs);
             for (const alias of partialAliases) {
               const namedFlag = resolvedAliases[alias];
@@ -61696,80 +61719,13 @@ function listAllRouteNamesAndAliasesForScan(routeMap, scannerCaseStyle, config)
     return [routeName];
   });
 }
-var text_en = {
-  headers: {
-    usage: "USAGE",
-    aliases: "ALIASES",
-    commands: "COMMANDS",
-    flags: "FLAGS",
-    arguments: "ARGUMENTS"
-  },
-  keywords: {
-    default: "default =",
-    separator: "separator ="
-  },
-  briefs: {
-    help: "Print help information and exit",
-    helpAll: "Print help information (including hidden commands/flags) and exit",
-    version: "Print version information and exit",
-    argumentEscapeSequence: "All subsequent inputs should be interpreted as arguments"
-  },
-  noCommandRegisteredForInput({ input, corrections }) {
-    const errorMessage = `No command registered for \`${input}\``;
-    if (corrections.length > 0) {
-      const formattedCorrections = joinWithGrammar(corrections, {
-        kind: "conjunctive",
-        conjunction: "or",
-        serialComma: true
-      });
-      return `${errorMessage}, did you mean ${formattedCorrections}?`;
-    } else {
-      return errorMessage;
-    }
-  },
-  noTextAvailableForLocale({ requestedLocale, defaultLocale }) {
-    return `Application does not support "${requestedLocale}" locale, defaulting to "${defaultLocale}"`;
-  },
-  exceptionWhileParsingArguments(exc) {
-    if (exc instanceof ArgumentScannerError) {
-      return formatMessageForArgumentScannerError(exc, {});
-    }
-    return `Unable to parse arguments, ${(this.formatException ?? formatException)(exc)}`;
-  },
-  exceptionWhileLoadingCommandFunction(exc) {
-    return `Unable to load command function, ${(this.formatException ?? formatException)(exc)}`;
-  },
-  exceptionWhileLoadingCommandContext(exc) {
-    return `Unable to load command context, ${(this.formatException ?? formatException)(exc)}`;
-  },
-  exceptionWhileRunningCommand(exc) {
-    return `Command failed, ${(this.formatException ?? formatException)(exc)}`;
-  },
-  commandErrorResult(err) {
-    return err.message;
-  },
-  currentVersionIsNotLatest({ currentVersion, latestVersion, upgradeCommand }) {
-    if (upgradeCommand) {
-      return `Latest available version is ${latestVersion} (currently running ${currentVersion}), upgrade with "${upgradeCommand}"`;
-    }
-    return `Latest available version is ${latestVersion} (currently running ${currentVersion})`;
-  }
-};
-function defaultTextLoader(locale) {
-  if (locale.startsWith("en")) {
-    return text_en;
-  }
-}
-function shouldUseAnsiColor(process2, stream, config) {
-  return !config.disableAnsiColor && !checkEnvironmentVariable(process2, "STRICLI_NO_COLOR") && (stream.getColorDepth?.(process2.env) ?? 1) >= 4;
-}
 async function runCommand({ loader, parameters }, {
   context,
   inputs,
   scannerConfig,
   errorFormatting,
-  documentationConfig,
-  determineExitCode
+  determineExitCode,
+  ansiColorByStream
 }) {
   let parsedArguments;
   try {
@@ -61781,19 +61737,17 @@ async function runCommand({ loader, parameters }, {
     if (result.success) {
       parsedArguments = result.arguments;
     } else {
-      const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, documentationConfig);
       for (const error of result.errors) {
-        const errorMessage = errorFormatting.exceptionWhileParsingArguments(error, ansiColor);
-        context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+        const errorMessage = errorFormatting.exceptionWhileParsingArguments(error, ansiColorByStream.stderr);
+        context.process.stderr.write(ansiColorByStream.stderr ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
 ` : `${errorMessage}
 `);
       }
       return ExitCode.InvalidArgument;
     }
   } catch (exc) {
-    const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, documentationConfig);
-    const errorMessage = errorFormatting.exceptionWhileParsingArguments(exc, ansiColor);
-    context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+    const errorMessage = errorFormatting.exceptionWhileParsingArguments(exc, ansiColorByStream.stderr);
+    context.process.stderr.write(ansiColorByStream.stderr ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
 ` : `${errorMessage}
 `);
     return ExitCode.InvalidArgument;
@@ -61807,9 +61761,8 @@ async function runCommand({ loader, parameters }, {
       commandFunction = loaded.default;
     }
   } catch (exc) {
-    const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, documentationConfig);
-    const errorMessage = errorFormatting.exceptionWhileLoadingCommandFunction(exc, ansiColor);
-    context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+    const errorMessage = errorFormatting.exceptionWhileLoadingCommandFunction(exc, ansiColorByStream.stderr);
+    context.process.stderr.write(ansiColorByStream.stderr ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
 ` : `${errorMessage}
 `);
     return ExitCode.CommandLoadError;
@@ -61817,9 +61770,8 @@ async function runCommand({ loader, parameters }, {
   try {
     const result = await commandFunction.call(context, ...parsedArguments);
     if (result instanceof Error) {
-      const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, documentationConfig);
-      const errorMessage = errorFormatting.commandErrorResult(result, ansiColor);
-      context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+      const errorMessage = errorFormatting.commandErrorResult(result, ansiColorByStream.stderr);
+      context.process.stderr.write(ansiColorByStream.stderr ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
 ` : `${errorMessage}
 `);
       if (determineExitCode) {
@@ -61828,9 +61780,8 @@ async function runCommand({ loader, parameters }, {
       return ExitCode.CommandRunError;
     }
   } catch (exc) {
-    const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, documentationConfig);
-    const errorMessage = errorFormatting.exceptionWhileRunningCommand(exc, ansiColor);
-    context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+    const errorMessage = errorFormatting.exceptionWhileRunningCommand(exc, ansiColorByStream.stderr);
+    context.process.stderr.write(ansiColorByStream.stderr ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
 ` : `${errorMessage}
 `);
     if (determineExitCode) {
@@ -61842,14 +61793,26 @@ async function runCommand({ loader, parameters }, {
 }
 var RouteMapSymbol = Symbol("RouteMap");
 var CommandSymbol = Symbol("Command");
-function buildRouteScanner(root, config, startingPrefix) {
+function buildRouteScanner(root, config, startingPrefix, additionalFlags) {
   const prefix = [...startingPrefix];
   const unprocessedInputs = [];
+  const flags = {};
+  for (const additionalFlag of additionalFlags) {
+    flags[additionalFlag.name] = additionalFlag;
+  }
+  const aliases = {};
+  for (const additionalFlag of additionalFlags) {
+    if (additionalFlag.aliases) {
+      for (const alias of additionalFlag.aliases) {
+        aliases[alias] = additionalFlag.name;
+      }
+    }
+  }
+  const resolvedAliases = resolveAliases(flags, aliases, config.caseStyle);
+  let activeFlag;
   let parent;
   let current = root;
   let target;
-  let rootLevel = true;
-  let helpRequested = false;
   let treatInputsAsArguments = false;
   return {
     next: (input) => {
@@ -61858,22 +61821,20 @@ function buildRouteScanner(root, config, startingPrefix) {
         unprocessedInputs.push(input);
         return;
       }
-      if (!treatInputsAsArguments) {
-        if (input === "--help" || input === "-h") {
-          helpRequested = true;
-          if (!target) {
-            target = current;
-          }
-          return;
-        } else if (input === "--helpAll" || input === "--help-all" || input === "-H") {
-          helpRequested = "all";
-          if (!target) {
+      if (!treatInputsAsArguments && !activeFlag) {
+        try {
+          const nextFlags = findFlagsByArgument(input, flags, {}, resolvedAliases, config);
+          for (const currentFlag of nextFlags) {
+            if (!currentFlag[1].global && current !== root) {
+              continue;
+            }
+            activeFlag = currentFlag[1];
             target = current;
+            return;
           }
-          return;
-        }
+        } catch {}
       }
-      if (target) {
+      if (target || treatInputsAsArguments) {
         unprocessedInputs.push(input);
         return;
       }
@@ -61893,123 +61854,413 @@ function buildRouteScanner(root, config, startingPrefix) {
       }
       if (!next) {
         const defaultCommand = current.getDefaultCommand();
+        unprocessedInputs.push(input);
         if (defaultCommand) {
-          rootLevel = false;
           parent = [current, ""];
-          unprocessedInputs.push(input);
           current = defaultCommand;
           return;
         }
         return { input, routeMap: current };
       }
-      rootLevel = false;
       parent = [current, input];
       current = next;
       prefix.push(input);
     },
     finish: () => {
       target = target ?? current;
-      if (target.kind === RouteMapSymbol && !helpRequested) {
+      if (target.kind === RouteMapSymbol && !activeFlag) {
         const defaultCommand = target.getDefaultCommand();
         if (defaultCommand) {
           parent = [target, ""];
           target = defaultCommand;
-          rootLevel = false;
         }
       }
-      const aliases = parent ? parent[0].getOtherAliasesForInput(parent[1], config.caseStyle) : { original: [], "convert-camel-to-kebab": [] };
+      const aliases2 = parent ? parent[0].getOtherAliasesForInput(parent[1], config.caseStyle) : { original: [], "convert-camel-to-kebab": [] };
       return {
         target,
         unprocessedInputs,
-        helpRequested,
         prefix,
-        rootLevel,
-        aliases
+        aliases: aliases2,
+        activeFlag
       };
     }
   };
 }
-async function runApplication({ root, defaultText, config }, rawInputs, context) {
-  let text = defaultText;
-  if (context.locale && "loadText" in config.localization) {
-    const localeText = config.localization.loadText(context.locale);
-    if (localeText) {
-      text = localeText;
-    } else {
-      const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, config.documentation);
-      const warningMessage = text.noTextAvailableForLocale({
-        requestedLocale: context.locale,
-        defaultLocale: config.localization.defaultLocale,
-        ansiColor
+function checkEnvironmentVariable(process2, varName) {
+  const value = process2.env?.[varName];
+  return typeof value === "string" && looseBooleanParser(value);
+}
+var text_en = {
+  headers: {
+    usage: "USAGE",
+    aliases: "ALIASES",
+    commands: "COMMANDS",
+    flags: "FLAGS",
+    arguments: "ARGUMENTS"
+  },
+  keywords: {
+    default: "default =",
+    separator: "separator ="
+  },
+  briefs: {
+    help: "Print help information and exit",
+    helpAll: "Print help information (including hidden commands/flags) and exit",
+    version: "Print version information and exit",
+    argumentEscapeSequence: "All subsequent inputs should be interpreted as arguments"
+  },
+  noCommandRegisteredForInput({ input, corrections }) {
+    const errorMessage = `No command registered for \`${input}\``;
+    if (corrections.length > 0) {
+      const formattedCorrections = joinWithGrammar(corrections, {
+        kind: "conjunctive",
+        conjunction: "or",
+        serialComma: true
       });
-      context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[33m${warningMessage}\x1B[39m\x1B[22m
+      return `${errorMessage}, did you mean ${formattedCorrections}?`;
+    } else {
+      return errorMessage;
+    }
+  },
+  noTextAvailableForLocale({ requestedLocale, defaultLocale }) {
+    return `Application does not support "${requestedLocale}" locale, defaulting to "${defaultLocale}"`;
+  },
+  exceptionWhileParsingArguments(exc) {
+    if (exc instanceof ArgumentScannerError) {
+      return formatMessageForArgumentScannerError(exc, {});
+    }
+    return `Unable to parse arguments, ${(this.formatException ?? formatException)(exc)}`;
+  },
+  exceptionWhileLoadingCommandFunction(exc) {
+    return `Unable to load command function, ${(this.formatException ?? formatException)(exc)}`;
+  },
+  exceptionWhileLoadingCommandContext(exc) {
+    return `Unable to load command context, ${(this.formatException ?? formatException)(exc)}`;
+  },
+  exceptionWhileRunningCommand(exc) {
+    return `Command failed, ${(this.formatException ?? formatException)(exc)}`;
+  },
+  exceptionWhileRunningIntegrationHook({ exception, hook, integration }) {
+    return `Unexpected exception thrown by '${integration}' integration during '${hook}' hook.
+${(this.formatException ?? formatException)(exception)}`;
+  },
+  exceptionWhileRunningIntegrationFlag({ exception, integration }) {
+    return `Unexpected exception thrown by "--${integration}" flag from the '${integration}' integration.
+${(this.formatException ?? formatException)(exception)}`;
+  },
+  commandErrorResult(err) {
+    return err.message;
+  },
+  currentVersionIsNotLatest({ currentVersion, latestVersion, upgradeCommand }) {
+    if (upgradeCommand) {
+      return `Latest available version is ${latestVersion} (currently running ${currentVersion}), upgrade with "${upgradeCommand}"`;
+    }
+    return `Latest available version is ${latestVersion} (currently running ${currentVersion})`;
+  }
+};
+function defaultTextLoader(locale) {
+  if (locale.startsWith("en")) {
+    return text_en;
+  }
+}
+function shouldUseAnsiColor(process2, stream, config) {
+  return !config.disableAnsiColor && !checkEnvironmentVariable(process2, "STRICLI_NO_COLOR") && (stream.getColorDepth?.(process2.env) ?? 1) >= 4;
+}
+function shouldUseAnsiColorForStreams(process2, config) {
+  return {
+    stdout: shouldUseAnsiColor(process2, process2.stdout, config),
+    stderr: shouldUseAnsiColor(process2, process2.stderr, config)
+  };
+}
+function validateCaseStyleCompatibility(scan, display) {
+  if (scan === "original" && display === "convert-camel-to-kebab") {
+    throw new Error("Cannot convert route and flag names on display (convert-camel-to-kebab) but scan as original");
+  }
+}
+function help({
+  alias = "h",
+  includeHidden = false,
+  formatting,
+  ...config
+}) {
+  return {
+    validate(_root, config2) {
+      validateCaseStyleCompatibility(config2.scanner.caseStyle, formatting.caseStyle);
+    },
+    flag: {
+      ...config,
+      global: true,
+      aliases: alias === false ? [] : [alias],
+      async run(app, { text, ansiColorByStream, result, additionalFlags }) {
+        this.process.stdout.write(result.target.formatHelp({
+          prefix: result.prefix,
+          additionalFlags,
+          includeArgumentEscapeSequenceFlag: app.config.scanner.allowArgumentEscapeSequence,
+          includeHidden,
+          config: formatting,
+          aliases: result.aliases[formatting.caseStyle],
+          text,
+          ansiColor: ansiColorByStream.stdout
+        }));
+      }
+    }
+  };
+}
+function version({
+  info,
+  alias = "v",
+  hook = "app:start",
+  ...config
+}) {
+  let versionCheck;
+  if (info.getLatestVersion) {
+    const getLatestVersion = info.getLatestVersion;
+    versionCheck = async function({ text, ansiColorByStream }) {
+      if (checkEnvironmentVariable(this.process, "STRICLI_SKIP_VERSION_CHECK")) {
+        return;
+      }
+      let currentVersion;
+      if ("currentVersion" in info) {
+        currentVersion = info.currentVersion;
+      } else {
+        currentVersion = await info.getCurrentVersion.call(this);
+      }
+      const latestVersion = await getLatestVersion.call(this, currentVersion);
+      if (latestVersion && currentVersion !== latestVersion) {
+        const warningMessage = text.currentVersionIsNotLatest({
+          currentVersion,
+          latestVersion,
+          upgradeCommand: info.upgradeCommand,
+          ansiColor: ansiColorByStream.stderr
+        });
+        this.process.stderr.write(ansiColorByStream.stderr ? `\x1B[1m\x1B[33m${warningMessage}\x1B[39m\x1B[22m
 ` : `${warningMessage}
 `);
+      }
+    };
+  }
+  return {
+    hooks: versionCheck ? { [hook]: versionCheck } : {},
+    flag: {
+      ...config,
+      defaultForRouteMap: false,
+      global: false,
+      aliases: alias === false ? [] : [alias],
+      async run() {
+        let currentVersion;
+        if ("currentVersion" in info) {
+          currentVersion = info.currentVersion;
+        } else {
+          currentVersion = await info.getCurrentVersion.call(this);
+        }
+        this.process.stdout.write(currentVersion + `
+`);
+      }
+    }
+  };
+}
+async function runHook(integrations, hookName, context, args) {
+  for (const [name, integration] of Object.entries(integrations)) {
+    const hook = integration.hooks?.[hookName];
+    if (hook) {
+      try {
+        await hook.call(context, args);
+      } catch (exc) {
+        const errorMessage = args.text.exceptionWhileRunningIntegrationHook({
+          exception: exc,
+          hook: hookName,
+          integration: name,
+          ansiColor: args.ansiColorByStream.stderr
+        });
+        context.process.stderr.write(args.ansiColorByStream.stderr ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+` : `${errorMessage}
+`);
+        return ExitCode.IntegrationError;
+      }
+    }
+  }
+}
+function checkIntegrationsForCollisions(integrations, caseStyle) {
+  let routeMapDefault;
+  const flagNames = new Set(Object.keys(integrations));
+  const aliases = /* @__PURE__ */ new Map;
+  for (const [name, integration] of Object.entries(integrations)) {
+    if (caseStyle === "allow-kebab-for-camel") {
+      const camelCase = convertKebabCaseToCamelCase(name);
+      if (camelCase !== name && flagNames.has(camelCase)) {
+        throw new InternalError(`Multiple integrations are trying to use the same flag name (with 'allow-kebab-for-camel'): '${name}' and '${camelCase}'`);
+      }
+    }
+    if (integration.flag) {
+      if (integration.flag.defaultForRouteMap) {
+        if (routeMapDefault) {
+          throw new InternalError(`Multiple integrations provide a default flag for route maps: '${routeMapDefault}' and '${name}'`);
+        }
+        routeMapDefault = name;
+      }
+      for (const alias of integration.flag.aliases ?? []) {
+        const flagForAlias = aliases.get(alias);
+        if (flagForAlias) {
+          throw new InternalError(`Multiple integrations are trying to use the same flag alias "-${alias}": '${flagForAlias}' and '${name}'`);
+        }
+        aliases.set(alias, name);
+      }
     }
   }
-  if (config.versionInfo?.getLatestVersion && !checkEnvironmentVariable(context.process, "STRICLI_SKIP_VERSION_CHECK")) {
-    let currentVersion;
-    if ("currentVersion" in config.versionInfo) {
-      currentVersion = config.versionInfo.currentVersion;
+}
+function checkIntegrationsForFlagNameConflicts(root, additionalFlags, caseStyle) {
+  function checkForConflicts(target, prefix) {
+    if (target.kind === CommandSymbol) {
+      const relevantFlags = root === target ? additionalFlags : additionalFlags.filter(({ global: global2 }) => global2);
+      for (const { name, aliases } of relevantFlags) {
+        if (target.usesFlag(name, caseStyle)) {
+          throw new InternalError(`'${name}' integration provides a flag that would override: "${[...prefix, `--${name}`].join(" ")}"`);
+        }
+        for (const alias of aliases ?? []) {
+          if (target.usesFlag(alias, caseStyle)) {
+            throw new InternalError(`'${name}' integration provides a flag with an alias that would override: "${[...prefix, `-${alias}`].join(" ")}"`);
+          }
+        }
+      }
     } else {
-      currentVersion = await config.versionInfo.getCurrentVersion.call(context);
-    }
-    const latestVersion = await config.versionInfo.getLatestVersion.call(context, currentVersion);
-    if (latestVersion && currentVersion !== latestVersion) {
-      const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, config.documentation);
-      const warningMessage = text.currentVersionIsNotLatest({
-        currentVersion,
-        latestVersion,
-        upgradeCommand: config.versionInfo.upgradeCommand,
-        ansiColor
+      for (const entry of target.getAllEntries()) {
+        checkForConflicts(entry.target, [...prefix, entry.name.original]);
+      }
+    }
+  }
+  checkForConflicts(root, []);
+}
+function gatherAdditionalFlagsFromIntegrations(integrations) {
+  const flags = [];
+  for (const [name, integration] of Object.entries(integrations)) {
+    if (integration.flag) {
+      flags.push({ ...integration.flag, name });
+    }
+  }
+  return flags;
+}
+function validateIntegrations(integrations, root, config) {
+  for (const [name, integration] of Object.entries(integrations)) {
+    try {
+      integration.validate?.(root, config);
+    } catch (exc) {
+      throw new InternalError(`Integration '${name}' failed validation: ${String(exc)}`, { cause: exc });
+    }
+  }
+}
+function gatherDefaultIntegrations(config, text) {
+  const integrations = {
+    help: help({
+      brief: text.briefs.help,
+      alias: "h",
+      defaultForRouteMap: true,
+      includeHidden: false,
+      formatting: config.documentation
+    }),
+    helpAll: help({
+      brief: text.briefs.helpAll,
+      alias: "H",
+      hidden: !config.documentation.alwaysShowHelpAllFlag,
+      includeHidden: true,
+      formatting: config.documentation
+    })
+  };
+  if (config.versionInfo) {
+    integrations["version"] = version({
+      brief: text.briefs.version,
+      info: config.versionInfo,
+      alias: "v",
+      hook: "app:start"
+    });
+  }
+  return integrations;
+}
+async function runApplication(app, rawInputs, context) {
+  const ansiColorByStream = shouldUseAnsiColorForStreams(context.process, app.config.documentation);
+  let text = app.defaultText;
+  if (context.locale && "loadText" in app.config.localization) {
+    const localeText = app.config.localization.loadText(context.locale);
+    if (localeText) {
+      text = localeText;
+    } else {
+      const warningMessage = text.noTextAvailableForLocale({
+        requestedLocale: context.locale,
+        defaultLocale: app.config.localization.defaultLocale,
+        ansiColor: ansiColorByStream.stderr
       });
-      context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[33m${warningMessage}\x1B[39m\x1B[22m
+      context.process.stderr.write(ansiColorByStream.stderr ? `\x1B[1m\x1B[33m${warningMessage}\x1B[39m\x1B[22m
 ` : `${warningMessage}
 `);
     }
   }
-  const inputs = rawInputs.slice();
-  if (config.versionInfo && (inputs[0] === "--version" || inputs[0] === "-v")) {
-    let currentVersion;
-    if ("currentVersion" in config.versionInfo) {
-      currentVersion = config.versionInfo.currentVersion;
-    } else {
-      currentVersion = await config.versionInfo.getCurrentVersion.call(context);
-    }
-    context.process.stdout.write(currentVersion + `
-`);
-    return ExitCode.Success;
+  const hookStartExitCode = await runHook(app.integrations, "app:start", context, {
+    text,
+    ansiColorByStream
+  });
+  if (typeof hookStartExitCode === "number") {
+    return hookStartExitCode;
+  }
+  const exitCode = await scanInputsAndRunTarget(app, rawInputs, context, text, ansiColorByStream);
+  const hookEndExitCode = await runHook(app.integrations, "app:end", context, {
+    text,
+    ansiColorByStream,
+    exitCode
+  });
+  if (typeof hookEndExitCode === "number") {
+    return hookEndExitCode;
   }
-  const scanner = buildRouteScanner(root, config.scanner, [config.name]);
+  return exitCode;
+}
+async function scanInputsAndRunTarget(app, rawInputs, context, text, ansiColorByStream) {
+  const additionalFlags = gatherAdditionalFlagsFromIntegrations(app.integrations);
+  const inputs = rawInputs.slice();
+  const scanner = buildRouteScanner(app.root, app.config.scanner, [app.config.name], additionalFlags);
   let error;
   while (inputs.length > 0 && !error) {
     const arg = inputs.shift();
     error = scanner.next(arg);
   }
   if (error) {
-    const routeNames = listAllRouteNamesAndAliasesForScan(error.routeMap, config.scanner.caseStyle, config.completion);
-    const corrections = filterClosestAlternatives(error.input, routeNames, config.scanner.distanceOptions).map((str) => `\`${str}\``);
-    const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, config.documentation);
-    const errorMessage = text.noCommandRegisteredForInput({ input: error.input, corrections, ansiColor });
-    context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+    const routeNames = listAllRouteNamesAndAliasesForScan(error.routeMap, app.config.scanner.caseStyle, app.config.completion);
+    const corrections = filterClosestAlternatives(error.input, routeNames, app.config.scanner.distanceOptions).map((str) => `\`${str}\``);
+    const errorMessage = text.noCommandRegisteredForInput({
+      input: error.input,
+      corrections,
+      ansiColor: ansiColorByStream.stderr
+    });
+    context.process.stderr.write(ansiColorByStream.stderr ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
 ` : `${errorMessage}
 `);
     return ExitCode.UnknownCommand;
   }
-  const result = scanner.finish();
-  if (result.helpRequested || result.target.kind === RouteMapSymbol) {
-    const ansiColor = shouldUseAnsiColor(context.process, context.process.stdout, config.documentation);
-    context.process.stdout.write(result.target.formatHelp({
-      prefix: result.prefix,
-      includeVersionFlag: Boolean(config.versionInfo) && result.rootLevel,
-      includeArgumentEscapeSequenceFlag: config.scanner.allowArgumentEscapeSequence,
-      includeHelpAllFlag: result.helpRequested === "all" || config.documentation.alwaysShowHelpAllFlag,
-      includeHidden: result.helpRequested === "all",
-      config: config.documentation,
-      aliases: result.aliases[config.documentation.caseStyle],
-      text,
-      ansiColor
-    }));
+  let { activeFlag, ...result } = scanner.finish();
+  if (activeFlag || result.target.kind === RouteMapSymbol) {
+    if (!activeFlag) {
+      activeFlag = additionalFlags.find((flag) => flag.defaultForRouteMap);
+    }
+    if (activeFlag) {
+      let additionalFlagsForTarget = additionalFlags;
+      if (result.target !== app.root) {
+        additionalFlagsForTarget = additionalFlagsForTarget.filter((flag) => flag.global);
+      }
+      try {
+        await activeFlag.run.call(context, app, {
+          text,
+          ansiColorByStream,
+          result,
+          additionalFlags: additionalFlagsForTarget
+        });
+      } catch (exc) {
+        const errorMessage = text.exceptionWhileRunningIntegrationFlag({
+          exception: exc,
+          ansiColor: ansiColorByStream.stderr,
+          integration: activeFlag.name
+        });
+        context.process.stderr.write(ansiColorByStream.stderr ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m
+` : `${errorMessage}
+`);
+        return ExitCode.IntegrationError;
+      }
+    }
     return ExitCode.Success;
   }
   let commandContext;
@@ -62017,117 +62268,62 @@ async function runApplication({ root, defaultText, config }, rawInputs, context)
     try {
       commandContext = await context.forCommand({ prefix: result.prefix });
     } catch (exc) {
-      const ansiColor = shouldUseAnsiColor(context.process, context.process.stderr, config.documentation);
-      const errorMessage = text.exceptionWhileLoadingCommandContext(exc, ansiColor);
-      context.process.stderr.write(ansiColor ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m` : errorMessage);
+      const errorMessage = text.exceptionWhileLoadingCommandContext(exc, ansiColorByStream.stderr);
+      context.process.stderr.write(ansiColorByStream.stderr ? `\x1B[1m\x1B[31m${errorMessage}\x1B[39m\x1B[22m` : errorMessage);
       return ExitCode.ContextLoadError;
     }
   } else {
     commandContext = context;
   }
-  return runCommand(result.target, {
+  const hookStartExitCode = await runHook(app.integrations, "command:start", commandContext, {
+    text,
+    ansiColorByStream,
+    result
+  });
+  if (typeof hookStartExitCode === "number") {
+    return hookStartExitCode;
+  }
+  const exitCode = await runCommand(result.target, {
     context: commandContext,
     inputs: result.unprocessedInputs,
-    scannerConfig: config.scanner,
-    documentationConfig: config.documentation,
+    scannerConfig: app.config.scanner,
     errorFormatting: text,
-    determineExitCode: config.determineExitCode
+    determineExitCode: app.config.determineExitCode,
+    ansiColorByStream
   });
-}
-function formatForDisplay(flagName, displayCaseStyle) {
-  if (displayCaseStyle === "convert-camel-to-kebab") {
-    return convertCamelCaseToKebabCase(flagName);
+  const hookEndExitCode = await runHook(app.integrations, "command:end", commandContext, {
+    text,
+    ansiColorByStream,
+    result,
+    exitCode
+  });
+  if (typeof hookEndExitCode === "number") {
+    return hookEndExitCode;
   }
-  return flagName;
+  return exitCode;
 }
-function formatAsNegated(flagName, displayCaseStyle) {
-  if (displayCaseStyle === "convert-camel-to-kebab") {
-    return `no-${convertCamelCaseToKebabCase(flagName)}`;
-  }
-  return `no${flagName[0].toUpperCase()}${flagName.slice(1)}`;
+function hasDefault(flag) {
+  return "default" in flag && typeof flag.default !== "undefined";
 }
-function withDefaults(config) {
-  const scannerCaseStyle = config.scanner?.caseStyle ?? "original";
+function isOptionalAtRuntime(flag) {
+  return flag.optional ?? hasDefault(flag);
+}
+function withDefaultFormattingConfiguration(config, scannerCaseStyle) {
   let displayCaseStyle;
-  if (config.documentation?.caseStyle) {
-    if (scannerCaseStyle === "original" && config.documentation.caseStyle === "convert-camel-to-kebab") {
-      throw new InternalError("Cannot convert route and flag names on display but scan as original");
-    }
-    displayCaseStyle = config.documentation.caseStyle;
+  if (config.caseStyle) {
+    displayCaseStyle = config.caseStyle;
   } else if (scannerCaseStyle === "allow-kebab-for-camel") {
     displayCaseStyle = "convert-camel-to-kebab";
   } else {
     displayCaseStyle = scannerCaseStyle;
   }
-  const scannerConfig = {
-    caseStyle: scannerCaseStyle,
-    allowArgumentEscapeSequence: config.scanner?.allowArgumentEscapeSequence ?? false,
-    distanceOptions: config.scanner?.distanceOptions ?? {
-      threshold: 7,
-      weights: {
-        insertion: 1,
-        deletion: 3,
-        substitution: 2,
-        transposition: 0
-      }
-    }
-  };
-  const documentationConfig = {
-    alwaysShowHelpAllFlag: config.documentation?.alwaysShowHelpAllFlag ?? false,
-    useAliasInUsageLine: config.documentation?.useAliasInUsageLine ?? false,
-    onlyRequiredInUsageLine: config.documentation?.onlyRequiredInUsageLine ?? false,
-    caseStyle: displayCaseStyle,
-    disableAnsiColor: config.documentation?.disableAnsiColor ?? false
-  };
-  const completionConfig = {
-    includeAliases: config.completion?.includeAliases ?? documentationConfig.useAliasInUsageLine,
-    includeHiddenRoutes: config.completion?.includeHiddenRoutes ?? false,
-    ...config.completion
-  };
+  validateCaseStyleCompatibility(scannerCaseStyle, displayCaseStyle);
   return {
-    ...config,
-    scanner: scannerConfig,
-    completion: completionConfig,
-    documentation: documentationConfig,
-    localization: {
-      defaultLocale: "en",
-      loadText: defaultTextLoader,
-      ...config.localization
-    }
+    useAliasInUsageLine: config.useAliasInUsageLine ?? false,
+    onlyRequiredInUsageLine: config.onlyRequiredInUsageLine ?? false,
+    caseStyle: displayCaseStyle
   };
 }
-function buildApplication(root, appConfig) {
-  const config = withDefaults(appConfig);
-  if (root.kind === CommandSymbol && config.versionInfo) {
-    if (root.usesFlag("version")) {
-      throw new InternalError("Unable to use command with flag --version as root when version info is supplied");
-    }
-    if (root.usesFlag("v")) {
-      throw new InternalError("Unable to use command with alias -v as root when version info is supplied");
-    }
-  }
-  let defaultText;
-  if ("text" in config.localization) {
-    defaultText = config.localization.text;
-  } else {
-    const text = config.localization.loadText(config.localization.defaultLocale);
-    if (!text) {
-      throw new InternalError(`No text available for the default locale "${config.localization.defaultLocale}"`);
-    }
-    defaultText = text;
-  }
-  return {
-    root,
-    config,
-    defaultText
-  };
-}
-function hasDefault(flag) {
-  return "default" in flag && typeof flag.default !== "undefined";
-}
-function isOptionalAtRuntime(flag) {
-  return flag.optional ?? hasDefault(flag);
-}
 function wrapRequiredFlag(text) {
   return `(${text})`;
 }
@@ -62201,8 +62397,92 @@ function formatUsageLineForParameters(parameters, args) {
   }
   return [...args.prefix, ...flagsUsage, ...positionalUsage].join(" ");
 }
+function formatForDisplay(flagName, displayCaseStyle) {
+  if (displayCaseStyle === "convert-camel-to-kebab") {
+    return convertCamelCaseToKebabCase(flagName);
+  }
+  return flagName;
+}
+function formatAsNegated(flagName, displayCaseStyle) {
+  if (displayCaseStyle === "convert-camel-to-kebab") {
+    return `no-${convertCamelCaseToKebabCase(flagName)}`;
+  }
+  return `no${flagName[0].toUpperCase()}${flagName.slice(1)}`;
+}
+function withDefaults(config) {
+  const scannerCaseStyle = config.scanner?.caseStyle ?? "original";
+  const scannerConfig = {
+    caseStyle: scannerCaseStyle,
+    allowArgumentEscapeSequence: config.scanner?.allowArgumentEscapeSequence ?? false,
+    distanceOptions: config.scanner?.distanceOptions ?? {
+      threshold: 7,
+      weights: {
+        insertion: 1,
+        deletion: 3,
+        substitution: 2,
+        transposition: 0
+      }
+    }
+  };
+  const documentationConfig = {
+    alwaysShowHelpAllFlag: config.documentation?.alwaysShowHelpAllFlag ?? false,
+    disableAnsiColor: config.documentation?.disableAnsiColor ?? false,
+    ...withDefaultFormattingConfiguration(config.documentation ?? {}, scannerCaseStyle)
+  };
+  const completionConfig = {
+    includeAliases: config.completion?.includeAliases ?? documentationConfig.useAliasInUsageLine,
+    includeHiddenRoutes: config.completion?.includeHiddenRoutes ?? false,
+    ...config.completion
+  };
+  return {
+    ...config,
+    scanner: scannerConfig,
+    completion: completionConfig,
+    documentation: documentationConfig,
+    localization: {
+      defaultLocale: "en",
+      loadText: defaultTextLoader,
+      ...config.localization
+    }
+  };
+}
+function buildApplication(root, appConfig, integrations) {
+  const config = withDefaults(appConfig);
+  let defaultText;
+  if ("text" in config.localization) {
+    defaultText = config.localization.text;
+  } else {
+    const text = config.localization.loadText(config.localization.defaultLocale);
+    if (!text) {
+      throw new InternalError(`No text available for the default locale "${config.localization.defaultLocale}"`);
+    }
+    defaultText = text;
+  }
+  if (integrations) {
+    checkIntegrationsForCollisions(integrations, config.scanner.caseStyle);
+  } else {
+    integrations = gatherDefaultIntegrations(config, defaultText);
+  }
+  const additionalFlags = gatherAdditionalFlagsFromIntegrations(integrations);
+  checkIntegrationsForFlagNameConflicts(root, additionalFlags, config.scanner.caseStyle);
+  validateIntegrations(integrations, root, config);
+  return {
+    root,
+    config,
+    defaultText,
+    integrations
+  };
+}
+function formatRowForAdditionalFlag(flag, caseStyle) {
+  return {
+    aliases: flag.aliases ? flag.aliases.map((alias) => `-${alias}`).join(" ") : "",
+    flagName: `--${formatForDisplay(flag.name, caseStyle)}`,
+    brief: flag.brief,
+    hidden: flag.hidden
+  };
+}
 function formatDocumentationForFlagParameters(flags, aliases, args) {
-  const { keywords, briefs } = args.text;
+  const { keywords } = args.text;
   const visibleFlags = Object.entries(flags).filter(([, flag]) => {
     if (flag.hidden && !args.includeHidden) {
       return false;
@@ -62258,32 +62538,21 @@ function formatDocumentationForFlagParameters(flags, aliases, args) {
       hidden: flag.hidden
     };
   });
-  rows.push({
-    aliases: "-h",
-    flagName: atLeastOneOptional ? " --help" : "--help",
-    brief: briefs.help
-  });
-  if (args.includeHelpAllFlag) {
-    const helpAllFlagName = formatForDisplay("helpAll", args.config.caseStyle);
-    rows.push({
-      aliases: "-H",
-      flagName: atLeastOneOptional ? ` --${helpAllFlagName}` : `--${helpAllFlagName}`,
-      brief: briefs.helpAll,
-      hidden: !args.config.alwaysShowHelpAllFlag
-    });
-  }
-  if (args.includeVersionFlag) {
+  for (const flag of args.additionalFlags) {
+    if (flag.hidden && !args.includeHidden) {
+      continue;
+    }
+    const row = formatRowForAdditionalFlag(flag, args.config.caseStyle);
     rows.push({
-      aliases: "-v",
-      flagName: atLeastOneOptional ? " --version" : "--version",
-      brief: briefs.version
+      ...row,
+      flagName: atLeastOneOptional ? ` ${row.flagName}` : row.flagName
     });
   }
   if (args.includeArgumentEscapeSequenceFlag) {
     rows.push({
       aliases: "",
       flagName: atLeastOneOptional ? " --" : "--",
-      brief: briefs.argumentEscapeSequence
+      brief: args.text.briefs.argumentEscapeSequence
     });
   }
   return formatRowsWithColumns(rows.map((row) => {
@@ -62298,14 +62567,16 @@ function formatDocumentationForFlagParameters(flags, aliases, args) {
     ];
   }), [" ", "  ", " "]);
 }
-function* generateBuiltInFlagUsageLines(args) {
-  yield args.config.useAliasInUsageLine ? "-h" : "--help";
-  if (args.includeHelpAllFlag) {
-    const helpAllFlagName = formatForDisplay("helpAll", args.config.caseStyle);
-    yield args.config.useAliasInUsageLine ? "-H" : `--${helpAllFlagName}`;
-  }
-  if (args.includeVersionFlag) {
-    yield args.config.useAliasInUsageLine ? "-v" : "--version";
+function* generateUsageLinesForAdditionalFlags(flags, includeHidden, caseStyle, useAliasInUsageLine) {
+  for (const flag of flags) {
+    if (flag.hidden && !includeHidden) {
+      continue;
+    }
+    if (useAliasInUsageLine && flag.aliases && flag.aliases.length > 0) {
+      yield `-${flag.aliases[0]}`;
+    } else {
+      yield `--${formatForDisplay(flag.name, caseStyle)}`;
+    }
   }
 }
 function formatDocumentationForPositionalParameters(positional, args) {
@@ -62354,7 +62625,7 @@ function* generateCommandHelpLines(parameters, docs, args) {
   } else {
     yield `  ${formatUsageLineForParameters(parameters, args)}`;
   }
-  for (const line of generateBuiltInFlagUsageLines(args)) {
+  for (const line of generateUsageLinesForAdditionalFlags(args.additionalFlags, args.includeHidden, args.config.caseStyle, args.config.useAliasInUsageLine)) {
     yield `  ${prefix} ${line}`;
   }
   yield "";
@@ -62381,20 +62652,6 @@ function* generateCommandHelpLines(parameters, docs, args) {
     }
   }
 }
-function checkForReservedFlags(flags, reserved) {
-  for (const flag of reserved) {
-    if (flag in flags) {
-      throw new InternalError(`Unable to use reserved flag --${flag}`);
-    }
-  }
-}
-function checkForReservedAliases(aliases, reserved) {
-  for (const alias of reserved) {
-    if (alias in aliases) {
-      throw new InternalError(`Unable to use reserved alias -${alias}`);
-    }
-  }
-}
 function* asNegationFlagNames(flagName) {
   yield `no-${convertCamelCaseToKebabCase(flagName)}`;
   yield `no${flagName[0].toUpperCase()}${flagName.slice(1)}`;
@@ -62423,8 +62680,6 @@ function checkForInvalidVariadicSeparators(flags) {
 }
 function buildCommand(builderArgs) {
   const { flags = {}, aliases = {} } = builderArgs.parameters;
-  checkForReservedFlags(flags, ["help", "helpAll", "help-all"]);
-  checkForReservedAliases(aliases, ["h", "H"]);
   checkForNegationCollisions(flags);
   checkForInvalidVariadicSeparators(flags);
   let loader;
@@ -62455,7 +62710,13 @@ function buildCommand(builderArgs) {
       return text + `
 `;
     },
-    usesFlag: (flagName) => {
+    usesFlag: (flagName, caseStyle) => {
+      if (caseStyle === "allow-kebab-for-camel") {
+        const kebabCase = convertCamelCaseToKebabCase(flagName);
+        if (kebabCase in flags) {
+          return true;
+        }
+      }
       return Boolean(flagName in flags || flagName in aliases);
     }
   };
@@ -62474,7 +62735,7 @@ function* generateRouteMapHelpLines(routes, docs, args) {
     }
   }
   const prefix = args.prefix.join(" ");
-  for (const line of generateBuiltInFlagUsageLines(args)) {
+  for (const line of generateUsageLinesForAdditionalFlags(args.additionalFlags, args.includeHidden, args.config.caseStyle, args.config.useAliasInUsageLine)) {
     yield `  ${prefix} ${line}`;
   }
   yield "";
@@ -62529,14 +62790,14 @@ function buildRouteMap({
   const aliasesByRoute = /* @__PURE__ */ new Map;
   for (const [alias, routeName] of Object.entries(activeAliases)) {
     if (alias in routes) {
-      throw new InternalError(`Cannot use "${alias}" as an alias when a route with that name already exists`);
+      throw new InternalError(`Cannot use '${alias}' as an alias when a route with that name already exists`);
     }
     const routeAliases = aliasesByRoute.get(routeName) ?? [];
     aliasesByRoute.set(routeName, [...routeAliases, alias]);
   }
   const defaultCommand = defaultCommandRoute ? routes[defaultCommandRoute] : undefined;
   if (defaultCommand && defaultCommand.kind === RouteMapSymbol) {
-    throw new InternalError(`Cannot use "${defaultCommandRoute}" as the default command because it is not a Command`);
+    throw new InternalError(`Cannot use '${defaultCommandRoute}' as the default command because it is not a Command`);
   }
   const resolveRouteName = (input) => {
     if (input in activeAliases) {
@@ -62557,8 +62818,8 @@ function buildRouteMap({
       const routeNames = this.getAllEntries().filter((entry) => !entry.hidden).map((entry) => entry.name[args.config.caseStyle]);
       return `${args.prefix.join(" ")} ${routeNames.join("|")} ...`;
     },
-    formatHelp: (config) => {
-      const lines = [...generateRouteMapHelpLines(routes, docs, config)];
+    formatHelp: (args) => {
+      const lines = [...generateRouteMapHelpLines(routes, docs, args)];
       const text = lines.join(`
 `);
       return text + `
@@ -62851,7 +63112,7 @@ var routes = buildRouteMap({
 var app = buildApplication(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.0.30"
+    currentVersion: "0.0.32"
   }
 });
 run(app, process4.argv.slice(2), buildContext(process4));
@@ -62859,5 +63120,5 @@ export {
   app
 };
 
-//# debugId=9864AA851D355E7364756E2164756E21
+//# debugId=7F1742DC6DB66A7464756E2164756E21
 //# sourceMappingURL=mcp-server.js.map