claude-use 11.54.1 → 11.56.0

package/dist/cli.cjs

@@ -1518,8 +1518,8 @@ function anchor(source) {
 }
 function timeSource(args) {
   const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
-  const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : args.seconds ? `${hhmm}:[0-5]\\d(?:\\.\\d+)?` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
-  return regex;
+  const regex2 = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : args.seconds ? `${hhmm}:[0-5]\\d(?:\\.\\d+)?` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
+  return regex2;
 }
 function time(args) {
   return new RegExp(`^${timeSource(args)}$`);
@@ -1587,8 +1587,8 @@ var init_regexes = __esm({
     date = /* @__PURE__ */ anchor(dateSource);
     anyString = /^[\s\S]{0,}$/;
     string = (params) => {
-      const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
-      return new RegExp(`^${regex}$`);
+      const regex2 = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+      return new RegExp(`^${regex2}$`);
     };
     bigint = /^-?\d+n?$/;
     integer = /^-?\d+$/;
@@ -4781,14 +4781,14 @@ var init_memoizer = __esm({
         (_a4 = inst._zod).deferred ?? (_a4.deferred = []);
         inst._zod.deferred.push(() => {
           const base = inst._zod.parse;
-          const wrapped = (payload, ctx) => {
+          const wrapped2 = (payload, ctx) => {
             if (ctx.direction !== "backward" && isBackEdge(ctx, payload.value))
               throw new $ZodCyclicError();
             return base(payload, ctx);
           };
-          inst._zod.parse = wrapped;
+          inst._zod.parse = wrapped2;
           if (inst._zod.run === base)
-            inst._zod.run = wrapped;
+            inst._zod.run = wrapped2;
         });
       },
       attach(inst) {
@@ -4800,12 +4800,12 @@ var init_memoizer = __esm({
         (_a4 = inst._zod).deferred ?? (_a4.deferred = []);
         inst._zod.deferred.push(() => {
           const base = inst._zod.parse;
-          const wrapped = (payload, ctx) => {
+          const wrapped2 = (payload, ctx) => {
             if (isRecursiveInst === void 0) {
               const walked = isRecursive(inst, /* @__PURE__ */ new Set(), false);
               if (walked === NONE) {
                 inst._zod.parse = base;
-                if (inst._zod.run === wrapped)
+                if (inst._zod.run === wrapped2)
                   inst._zod.run = base;
                 return base(payload, ctx);
               }
@@ -4859,9 +4859,9 @@ var init_memoizer = __esm({
               entry.issues = result.issues.length ? cloneIssues(result.issues) : NO_ISSUES;
             return result;
           };
-          inst._zod.parse = wrapped;
+          inst._zod.parse = wrapped2;
           if (inst._zod.run === base)
-            inst._zod.run = wrapped;
+            inst._zod.run = wrapped2;
         });
       }
     };
@@ -12959,7 +12959,7 @@ function withParser(schema, parser) {
   const clone3 = clone(schema);
   const liveRun = schema._zod.run;
   const originalRun = liveRun.__originalRun ?? liveRun;
-  const wrapped = (payload, ctx) => {
+  const wrapped2 = (payload, ctx) => {
     if (ctx?.async || ctx?.direction === "backward" || ctx?.skipChecks || ctx?.[FALLBACK_FLAG]) {
       return originalRun(payload, ctx);
     }
@@ -12975,10 +12975,10 @@ function withParser(schema, parser) {
       ctx[FALLBACK_FLAG] = true;
     return originalRun(payload, ctx);
   };
-  wrapped.__originalRun = originalRun;
+  wrapped2.__originalRun = originalRun;
   clone3._zod.bag.fallbackRun = originalRun;
   clone3._zod.bag.validator = parser;
-  clone3._zod.run = wrapped;
+  clone3._zod.run = wrapped2;
   if (!liveRun.__originalRun)
     installCompiledUserMethods(clone3, schema, parser);
   return clone3;
@@ -16402,9 +16402,9 @@ var init_json_schema_processors = __esm({
           json2.pattern = patternList[0].source;
         else if (patternList.length > 1) {
           json2.allOf = [
-            ...patternList.map((regex) => ({
+            ...patternList.map((regex2) => ({
               ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
-              pattern: regex.source
+              pattern: regex2.source
             }))
           ];
         }
@@ -17743,10 +17743,10 @@ function currencyCode2(_params) {
 function hash(alg, params) {
   const enc = params?.enc ?? "hex";
   const format = `${alg}_${enc}`;
-  const regex = regexes_exports[format];
-  if (!regex)
+  const regex2 = regexes_exports[format];
+  if (!regex2)
     throw new Error(`Unrecognized hash format: ${format}`);
-  return _stringFormat(ZodCustomStringFormat, format, regex, params);
+  return _stringFormat(ZodCustomStringFormat, format, regex2, params);
 }
 function number2(params) {
   return _number(ZodNumber, params);
@@ -19607,7 +19607,7 @@ function convertBaseSchema(schema, ctx) {
             for (const key of Object.keys(payload.value)) {
               if (propertyKeys.includes(key))
                 continue;
-              if (patterns.some((regex) => regex.test(key)))
+              if (patterns.some((regex2) => regex2.test(key)))
                 continue;
               unrecognized.push(key);
             }
@@ -25036,12 +25036,304 @@ var init_proxyBypass = __esm({
   }
 });
 
+// node_modules/.pnpm/ansi-regex@6.3.0/node_modules/ansi-regex/index.js
+function ansiRegex({ onlyFirst = false } = {}) {
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+  const osc = `(?:\\u001B\\][^\\u0007\\u001B\\u009C]*${ST})`;
+  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+  const pattern = `${osc}|${csi}`;
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+var init_ansi_regex = __esm({
+  "node_modules/.pnpm/ansi-regex@6.3.0/node_modules/ansi-regex/index.js"() {
+  }
+});
+
+// node_modules/.pnpm/strip-ansi@7.2.0/node_modules/strip-ansi/index.js
+function stripAnsi(string4) {
+  if (typeof string4 !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string4}\``);
+  }
+  if (!string4.includes("\x1B") && !string4.includes("\x9B")) {
+    return string4;
+  }
+  return string4.replace(regex, "");
+}
+var regex;
+var init_strip_ansi = __esm({
+  "node_modules/.pnpm/strip-ansi@7.2.0/node_modules/strip-ansi/index.js"() {
+    init_ansi_regex();
+    regex = ansiRegex();
+  }
+});
+
+// node_modules/.pnpm/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/lookup-data.js
+var ambiguousMinimalCodePoint, ambiguousMaximumCodePoint, ambiguousRanges, fullwidthMinimalCodePoint, fullwidthMaximumCodePoint, fullwidthRanges, wideMinimalCodePoint, wideMaximumCodePoint, wideRanges;
+var init_lookup_data = __esm({
+  "node_modules/.pnpm/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/lookup-data.js"() {
+    ambiguousMinimalCodePoint = 161;
+    ambiguousMaximumCodePoint = 1114109;
+    ambiguousRanges = [161, 161, 164, 164, 167, 168, 170, 170, 173, 174, 176, 180, 182, 186, 188, 191, 198, 198, 208, 208, 215, 216, 222, 225, 230, 230, 232, 234, 236, 237, 240, 240, 242, 243, 247, 250, 252, 252, 254, 254, 257, 257, 273, 273, 275, 275, 283, 283, 294, 295, 299, 299, 305, 307, 312, 312, 319, 322, 324, 324, 328, 331, 333, 333, 338, 339, 358, 359, 363, 363, 462, 462, 464, 464, 466, 466, 468, 468, 470, 470, 472, 472, 474, 474, 476, 476, 593, 593, 609, 609, 708, 708, 711, 711, 713, 715, 717, 717, 720, 720, 728, 731, 733, 733, 735, 735, 768, 879, 913, 929, 931, 937, 945, 961, 963, 969, 1025, 1025, 1040, 1103, 1105, 1105, 8208, 8208, 8211, 8214, 8216, 8217, 8220, 8221, 8224, 8226, 8228, 8231, 8240, 8240, 8242, 8243, 8245, 8245, 8251, 8251, 8254, 8254, 8308, 8308, 8319, 8319, 8321, 8324, 8364, 8364, 8451, 8451, 8453, 8453, 8457, 8457, 8467, 8467, 8470, 8470, 8481, 8482, 8486, 8486, 8491, 8491, 8531, 8532, 8539, 8542, 8544, 8555, 8560, 8569, 8585, 8585, 8592, 8601, 8632, 8633, 8658, 8658, 8660, 8660, 8679, 8679, 8704, 8704, 8706, 8707, 8711, 8712, 8715, 8715, 8719, 8719, 8721, 8721, 8725, 8725, 8730, 8730, 8733, 8736, 8739, 8739, 8741, 8741, 8743, 8748, 8750, 8750, 8756, 8759, 8764, 8765, 8776, 8776, 8780, 8780, 8786, 8786, 8800, 8801, 8804, 8807, 8810, 8811, 8814, 8815, 8834, 8835, 8838, 8839, 8853, 8853, 8857, 8857, 8869, 8869, 8895, 8895, 8978, 8978, 9312, 9449, 9451, 9547, 9552, 9587, 9600, 9615, 9618, 9621, 9632, 9633, 9635, 9641, 9650, 9651, 9654, 9655, 9660, 9661, 9664, 9665, 9670, 9672, 9675, 9675, 9678, 9681, 9698, 9701, 9711, 9711, 9733, 9734, 9737, 9737, 9742, 9743, 9756, 9756, 9758, 9758, 9792, 9792, 9794, 9794, 9824, 9825, 9827, 9829, 9831, 9834, 9836, 9837, 9839, 9839, 9886, 9887, 9919, 9919, 9926, 9933, 9935, 9939, 9941, 9953, 9955, 9955, 9960, 9961, 9963, 9969, 9972, 9972, 9974, 9977, 9979, 9980, 9982, 9983, 10045, 10045, 10102, 10111, 11094, 11097, 12872, 12879, 57344, 63743, 65024, 65039, 65533, 65533, 127232, 127242, 127248, 127277, 127280, 127337, 127344, 127373, 127375, 127376, 127387, 127404, 917760, 917999, 983040, 1048573, 1048576, 1114109];
+    fullwidthMinimalCodePoint = 12288;
+    fullwidthMaximumCodePoint = 65510;
+    fullwidthRanges = [12288, 12288, 65281, 65376, 65504, 65510];
+    wideMinimalCodePoint = 4352;
+    wideMaximumCodePoint = 262141;
+    wideRanges = [4352, 4447, 8986, 8987, 9001, 9002, 9193, 9196, 9200, 9200, 9203, 9203, 9725, 9726, 9748, 9749, 9776, 9783, 9800, 9811, 9855, 9855, 9866, 9871, 9875, 9875, 9889, 9889, 9898, 9899, 9917, 9918, 9924, 9925, 9934, 9934, 9940, 9940, 9962, 9962, 9970, 9971, 9973, 9973, 9978, 9978, 9981, 9981, 9989, 9989, 9994, 9995, 10024, 10024, 10060, 10060, 10062, 10062, 10067, 10069, 10071, 10071, 10133, 10135, 10160, 10160, 10175, 10175, 11035, 11036, 11088, 11088, 11093, 11093, 11904, 11929, 11931, 12019, 12032, 12245, 12272, 12287, 12289, 12350, 12353, 12438, 12441, 12543, 12549, 12591, 12593, 12686, 12688, 12773, 12783, 12830, 12832, 12871, 12880, 42124, 42128, 42182, 43360, 43388, 44032, 55203, 63744, 64255, 65040, 65049, 65072, 65106, 65108, 65126, 65128, 65131, 94176, 94180, 94192, 94198, 94208, 101589, 101631, 101662, 101760, 101874, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110882, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110951, 110960, 111355, 119552, 119638, 119648, 119670, 126980, 126980, 127183, 127183, 127374, 127374, 127377, 127386, 127488, 127490, 127504, 127547, 127552, 127560, 127568, 127569, 127584, 127589, 127744, 127776, 127789, 127797, 127799, 127868, 127870, 127891, 127904, 127946, 127951, 127955, 127968, 127984, 127988, 127988, 127992, 128062, 128064, 128064, 128066, 128252, 128255, 128317, 128331, 128334, 128336, 128359, 128378, 128378, 128405, 128406, 128420, 128420, 128507, 128591, 128640, 128709, 128716, 128716, 128720, 128722, 128725, 128728, 128732, 128735, 128747, 128748, 128756, 128764, 128992, 129003, 129008, 129008, 129292, 129338, 129340, 129349, 129351, 129535, 129648, 129660, 129664, 129674, 129678, 129734, 129736, 129736, 129741, 129756, 129759, 129770, 129775, 129784, 131072, 196605, 196608, 262141];
+  }
+});
+
+// node_modules/.pnpm/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/utilities.js
+var isInRange;
+var init_utilities = __esm({
+  "node_modules/.pnpm/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/utilities.js"() {
+    isInRange = (ranges, codePoint) => {
+      let low = 0;
+      let high = Math.floor(ranges.length / 2) - 1;
+      while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        const i10 = mid * 2;
+        if (codePoint < ranges[i10]) {
+          high = mid - 1;
+        } else if (codePoint > ranges[i10 + 1]) {
+          low = mid + 1;
+        } else {
+          return true;
+        }
+      }
+      return false;
+    };
+  }
+});
+
+// node_modules/.pnpm/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/lookup.js
+function findWideFastPathRange(ranges) {
+  let fastPathStart = ranges[0];
+  let fastPathEnd = ranges[1];
+  for (let index = 0; index < ranges.length; index += 2) {
+    const start = ranges[index];
+    const end = ranges[index + 1];
+    if (commonCjkCodePoint >= start && commonCjkCodePoint <= end) {
+      return [start, end];
+    }
+    if (end - start > fastPathEnd - fastPathStart) {
+      fastPathStart = start;
+      fastPathEnd = end;
+    }
+  }
+  return [fastPathStart, fastPathEnd];
+}
+var commonCjkCodePoint, wideFastPathStart, wideFastPathEnd, isAmbiguous, isFullWidth, isWide;
+var init_lookup = __esm({
+  "node_modules/.pnpm/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/lookup.js"() {
+    init_lookup_data();
+    init_utilities();
+    commonCjkCodePoint = 19968;
+    [wideFastPathStart, wideFastPathEnd] = /* @__PURE__ */ findWideFastPathRange(wideRanges);
+    isAmbiguous = (codePoint) => {
+      if (codePoint < ambiguousMinimalCodePoint || codePoint > ambiguousMaximumCodePoint) {
+        return false;
+      }
+      return isInRange(ambiguousRanges, codePoint);
+    };
+    isFullWidth = (codePoint) => {
+      if (codePoint < fullwidthMinimalCodePoint || codePoint > fullwidthMaximumCodePoint) {
+        return false;
+      }
+      return isInRange(fullwidthRanges, codePoint);
+    };
+    isWide = (codePoint) => {
+      if (codePoint >= wideFastPathStart && codePoint <= wideFastPathEnd) {
+        return true;
+      }
+      if (codePoint < wideMinimalCodePoint || codePoint > wideMaximumCodePoint) {
+        return false;
+      }
+      return isInRange(wideRanges, codePoint);
+    };
+  }
+});
+
+// node_modules/.pnpm/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/index.js
+function validate2(codePoint) {
+  if (!Number.isSafeInteger(codePoint)) {
+    throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+  }
+}
+function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
+  validate2(codePoint);
+  if (isFullWidth(codePoint) || isWide(codePoint) || ambiguousAsWide && isAmbiguous(codePoint)) {
+    return 2;
+  }
+  return 1;
+}
+var init_get_east_asian_width = __esm({
+  "node_modules/.pnpm/get-east-asian-width@1.6.0/node_modules/get-east-asian-width/index.js"() {
+    init_lookup();
+  }
+});
+
+// node_modules/.pnpm/string-width@8.3.0/node_modules/string-width/index.js
+function isDoubleWidthNonRgiEmojiSequence(segment) {
+  if (segment.length > 50) {
+    return false;
+  }
+  if (unqualifiedKeycapRegex.test(segment)) {
+    return true;
+  }
+  if (segment.includes("\u200D")) {
+    const pictographics = segment.match(extendedPictographicRegex);
+    return pictographics !== null && pictographics.length >= 2;
+  }
+  return false;
+}
+function baseVisible(segment) {
+  const index = segment.search(visibleCharacterRegex);
+  return index === -1 ? void 0 : segment.slice(index);
+}
+function isHangulLeadingJamo(codePoint) {
+  return codePoint >= 4352 && codePoint <= 4447 || codePoint >= 43360 && codePoint <= 43388;
+}
+function isHangulVowelJamo(codePoint) {
+  return codePoint >= 4448 && codePoint <= 4519 || codePoint >= 55216 && codePoint <= 55238;
+}
+function isHangulTrailingJamo(codePoint) {
+  return codePoint >= 4520 && codePoint <= 4607 || codePoint >= 55243 && codePoint <= 55291;
+}
+function isHangulJamo(codePoint) {
+  return isHangulLeadingJamo(codePoint) || isHangulVowelJamo(codePoint) || isHangulTrailingJamo(codePoint);
+}
+function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
+  const codePoints = [];
+  for (const character of visibleSegment) {
+    if (!visibleCharacterRegex.test(character)) {
+      continue;
+    }
+    codePoints.push(character.codePointAt(0));
+  }
+  if (codePoints.length === 0) {
+    return void 0;
+  }
+  let width = 0;
+  for (let index = 0; index < codePoints.length; index++) {
+    const codePoint = codePoints[index];
+    if (!isHangulJamo(codePoint)) {
+      if (width === 0) {
+        return void 0;
+      }
+      for (let remaining = index; remaining < codePoints.length; remaining++) {
+        width += eastAsianWidth(codePoints[remaining], eastAsianWidthOptions);
+      }
+      return width;
+    }
+    if (isHangulLeadingJamo(codePoint) && isHangulVowelJamo(codePoints[index + 1])) {
+      width += 2;
+      index += isHangulTrailingJamo(codePoints[index + 2]) ? 2 : 1;
+      continue;
+    }
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+  }
+  return width;
+}
+function trailingWidth(visibleSegment, eastAsianWidthOptions) {
+  let extra = 0;
+  let first = true;
+  for (const character of visibleSegment) {
+    if (first) {
+      first = false;
+      continue;
+    }
+    if (spacingMarkRegex.test(character) || character >= "\uFF00" && character <= "\uFFEF") {
+      extra += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
+    }
+  }
+  return extra;
+}
+function stringWidth(input2, options = {}) {
+  if (typeof input2 !== "string" || input2.length === 0) {
+    return 0;
+  }
+  const {
+    ambiguousIsNarrow = true,
+    countAnsiEscapeCodes = false
+  } = options;
+  let string4 = input2;
+  if (!countAnsiEscapeCodes && (string4.includes("\x1B") || string4.includes("\x9B"))) {
+    string4 = stripAnsi(string4);
+  }
+  if (string4.length === 0) {
+    return 0;
+  }
+  if (/^[\u0020-\u007E]*$/.test(string4)) {
+    return string4.length;
+  }
+  let width = 0;
+  const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+  for (const { segment } of segmenter.segment(string4)) {
+    const visibleSegment = baseVisible(segment);
+    if (visibleSegment === void 0) {
+      continue;
+    }
+    if (rgiEmojiRegex.test(segment) || isDoubleWidthNonRgiEmojiSequence(segment)) {
+      width += 2;
+      continue;
+    }
+    const hangulWidth = hangulClusterWidth(visibleSegment, eastAsianWidthOptions);
+    if (hangulWidth !== void 0) {
+      width += hangulWidth;
+      continue;
+    }
+    const codePoint = visibleSegment.codePointAt(0);
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+    width += trailingWidth(visibleSegment, eastAsianWidthOptions);
+  }
+  return width;
+}
+var segmenter, visibleCharacterRegex, spacingMarkRegex, rgiEmojiRegex, unqualifiedKeycapRegex, extendedPictographicRegex;
+var init_string_width = __esm({
+  "node_modules/.pnpm/string-width@8.3.0/node_modules/string-width/index.js"() {
+    init_strip_ansi();
+    init_get_east_asian_width();
+    segmenter = new Intl.Segmenter();
+    visibleCharacterRegex = new RegExp("[^\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Nonspacing_Mark}\\p{Enclosing_Mark}\\p{Surrogate}]", "v");
+    spacingMarkRegex = new RegExp("\\p{Spacing_Mark}", "v");
+    rgiEmojiRegex = new RegExp("^\\p{RGI_Emoji}$", "v");
+    unqualifiedKeycapRegex = /^[\d#*]\u20E3$/;
+    extendedPictographicRegex = new RegExp("\\p{Extended_Pictographic}", "gu");
+  }
+});
+
+// src/statusline/blank.ts
+function drawsNothing(text4) {
+  return stringWidth(text4.replace(BLANK_CELLS, "")) === 0;
+}
+var BLANK_CELLS;
+var init_blank = __esm({
+  "src/statusline/blank.ts"() {
+    "use strict";
+    init_string_width();
+    BLANK_CELLS = /[\p{Zs}\u2800\u3164\uFFA0]/gu;
+  }
+});
+
+// src/statusline/graphemes.ts
+function graphemesOf(text4) {
+  return Array.from(SEGMENTER.segment(text4), (part) => part.segment);
+}
+var SEGMENTER;
+var init_graphemes = __esm({
+  "src/statusline/graphemes.ts"() {
+    "use strict";
+    SEGMENTER = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+  }
+});
+
 // src/config/statusline.ts
 function distinctList(member) {
   return external_exports.array(member).refine((items) => new Set(items).size === items.length, "must not repeat an entry");
 }
 function isSingleVisibleGrapheme(text4) {
-  return [...GRAPHEMES.segment(text4)].length === 1 && !/[\p{C}\p{Z}]/u.test(text4);
+  return graphemesOf(text4).length === 1 && stringWidth(text4) === 1 && !/[\p{C}\p{Z}]/u.test(text4) && !drawsNothing(text4);
 }
 function isPlainObject2(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
@@ -25063,11 +25355,14 @@ function resolveStatusline(settings2) {
   }
   return resolved;
 }
-var STATUSLINE_HEADER_SEGMENTS, STATUSLINE_ROWS, STATUSLINE_COLOUR_NAMES, DEFAULT_HEADER_SEGMENTS, DEFAULT_ROWS, STATUSLINE_PATH_LEVELS, MAX_PERCENT, MAX_STATUSLINE_PALETTE_INDEX, MAX_STATUSLINE_LABEL_CHARS, MAX_BAR_CELLS, MAX_ACCOUNT_USER_CHARS, MAX_DISPLAY_TEXT_CHARS, LABEL_RE2, OPTIONAL_LABEL_RE, colourValue, GRAPHEMES, barCharacter, labelText, overrideText, wholePercent, SHAPES, StatuslineSchema, ResolvedStatuslineSchema, STATUSLINE_DEFAULTS, STATUSLINE_ENV;
+var STATUSLINE_HEADER_SEGMENTS, STATUSLINE_ROWS, STATUSLINE_COLOUR_NAMES, DEFAULT_HEADER_SEGMENTS, DEFAULT_ROWS, STATUSLINE_PATH_LEVELS, STATUSLINE_USAGE_VALUES, STATUSLINE_TIME_FORMATS, STATUSLINE_HOUR_CYCLES, MAX_PERCENT, MAX_STATUSLINE_PALETTE_INDEX, MAX_STATUSLINE_LABEL_COLUMNS, MAX_BAR_CELLS, MAX_ACCOUNT_USER_CHARS, MAX_DISPLAY_TEXT_CHARS, LABEL_RE2, OPTIONAL_LABEL_RE, colourValue, barCharacter, labelText, overrideText, wholePercent, thresholdPercent, SHAPES, StatuslineSchema, ResolvedStatuslineSchema, STATUSLINE_DEFAULTS, STATUSLINE_ENV;
 var init_statusline = __esm({
   "src/config/statusline.ts"() {
     "use strict";
+    init_string_width();
     init_zod();
+    init_blank();
+    init_graphemes();
     STATUSLINE_HEADER_SEGMENTS = ["model", "provider", "route", "account", "identity", "headroom", "project", "vcs", "effort", "advisor", "version", "outputStyle"];
     STATUSLINE_ROWS = ["context", "quota", "addedDirs", "gitFiles"];
     STATUSLINE_COLOUR_NAMES = [
@@ -25093,20 +25388,23 @@ var init_statusline = __esm({
     DEFAULT_HEADER_SEGMENTS = ["model", "provider", "route", "account", "identity", "headroom"];
     DEFAULT_ROWS = ["context", "quota"];
     STATUSLINE_PATH_LEVELS = ["1", "2", "3", "full"];
+    STATUSLINE_USAGE_VALUES = ["used", "remaining"];
+    STATUSLINE_TIME_FORMATS = ["relative", "absolute", "both", "elapsed", "elapsedAndAbsolute"];
+    STATUSLINE_HOUR_CYCLES = ["auto", "h11", "h12", "h23", "h24"];
     MAX_PERCENT = 100;
     MAX_STATUSLINE_PALETTE_INDEX = 255;
-    MAX_STATUSLINE_LABEL_CHARS = 12;
+    MAX_STATUSLINE_LABEL_COLUMNS = 12;
     MAX_BAR_CELLS = 40;
     MAX_ACCOUNT_USER_CHARS = 254;
     MAX_DISPLAY_TEXT_CHARS = 80;
     LABEL_RE2 = /^[^\p{C}\p{Z}]+(?: [^\p{C}\p{Z}]+)*$/u;
     OPTIONAL_LABEL_RE = /^(?:[^\p{C}\p{Z}]+(?: [^\p{C}\p{Z}]+)*)?$/u;
     colourValue = external_exports.union([external_exports.enum(STATUSLINE_COLOUR_NAMES), external_exports.number().int().min(0).max(MAX_STATUSLINE_PALETTE_INDEX), external_exports.string().regex(/^#[0-9a-fA-F]{6}$/, "must be a colour name, a palette index from 0 to 255 or #rrggbb")]);
-    GRAPHEMES = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-    barCharacter = external_exports.string().refine(isSingleVisibleGrapheme, "must be a single visible character");
-    labelText = external_exports.string().max(MAX_STATUSLINE_LABEL_CHARS).regex(LABEL_RE2, "must be visible text without control characters");
+    barCharacter = external_exports.string().refine(isSingleVisibleGrapheme, "must be a single visible character that takes one terminal column");
+    labelText = external_exports.string().refine((text4) => stringWidth(text4) <= MAX_STATUSLINE_LABEL_COLUMNS, `must take no more than ${String(MAX_STATUSLINE_LABEL_COLUMNS)} terminal columns`).refine((text4) => !drawsNothing(text4), "must show something: a label of only combining marks or blank characters draws nothing").regex(LABEL_RE2, "must be visible text without control characters");
     overrideText = external_exports.string().max(MAX_DISPLAY_TEXT_CHARS).regex(OPTIONAL_LABEL_RE, "must be visible text without control characters");
     wholePercent = external_exports.number().int().min(1).max(MAX_PERCENT);
+    thresholdPercent = external_exports.number().int().min(0).max(MAX_PERCENT);
     SHAPES = {
       layout: {
         header: distinctList(external_exports.enum(STATUSLINE_HEADER_SEGMENTS)).describe("The header segments to draw, in drawing order; a segment left out is hidden, and an empty list hides the header."),
@@ -25143,6 +25441,20 @@ var init_statusline = __esm({
         filled: barCharacter.describe("The character that draws the used part of a bar."),
         empty: barCharacter.describe("The character that draws the unused part of a bar.")
       },
+      usage: {
+        value: external_exports.enum(STATUSLINE_USAGE_VALUES).describe("Whether a quota window's figure is the share of it used or the share left; the bar and the colour always follow the share used."),
+        bar: external_exports.boolean().describe("Whether each quota window is drawn as a bar, or as text alone."),
+        compact: external_exports.boolean().describe("Whether the quota windows are drawn as one short line of text (`5h: 25.0% (1h 30m)`) in place of bars; it takes precedence over usage.bar."),
+        resetLabel: external_exports.boolean().describe("Whether a window's reset time is introduced with `resets in` (`resets` for a wall-clock time), as in `(resets in 1h 30m)`, rather than the bare `(1h 30m)`."),
+        modelScoped: external_exports.boolean().describe("Whether the per-model weekly windows the client reports (rate_limits.model_scoped) are drawn after the account's own windows; they describe the signed-in account, so a session that selected a provider never shows them."),
+        timeFormat: external_exports.enum(STATUSLINE_TIME_FORMATS).describe("How a window's reset is shown: the time left (`1h 30m`), the wall-clock time (`at 14:30`), both, the share of the window already gone (`53% elapsed`), or that share and the wall-clock time. A window whose length is not known shows no share."),
+        threshold: thresholdPercent.describe("The whole percentage of use that at least one quota window must reach for the quota row to be drawn at all; 0 always draws it."),
+        sevenDayThreshold: thresholdPercent.describe("The whole percentage of use at which the weekly window is drawn beside the five-hour one; below it the weekly window is hidden. A weekly window with no five-hour window beside it is always drawn, and 0 always draws it.")
+      },
+      clock: {
+        hourCycle: external_exports.enum(STATUSLINE_HOUR_CYCLES).describe("The hour cycle of a wall-clock time: `auto` follows the system locale, `h23` and `h24` are 24-hour time (`h24` writes midnight as 24:00), and `h12` and `h11` are 12-hour time with am or pm (`h11` writes the hour after midnight as 0)."),
+        seconds: external_exports.boolean().describe("Whether a wall-clock time includes seconds (`14:30:07`).")
+      },
       colours: {
         context: colourValue.describe("The colour of the context bar and its figures below the warning threshold."),
         usage: colourValue.describe("The colour of the quota bars and their figures below the warning threshold."),
@@ -25185,6 +25497,8 @@ var init_statusline = __esm({
       bands: external_exports.strictObject(SHAPES.bands).partial().optional(),
       labels: external_exports.strictObject(SHAPES.labels).partial().optional(),
       bar: external_exports.strictObject(SHAPES.bar).partial().optional(),
+      usage: external_exports.strictObject(SHAPES.usage).partial().optional(),
+      clock: external_exports.strictObject(SHAPES.clock).partial().optional(),
       colours: external_exports.strictObject(SHAPES.colours).partial().optional(),
       project: external_exports.strictObject(SHAPES.project).partial().optional(),
       git: external_exports.strictObject(SHAPES.git).partial().optional(),
@@ -25200,6 +25514,8 @@ var init_statusline = __esm({
       bands: external_exports.strictObject(SHAPES.bands),
       labels: external_exports.strictObject(SHAPES.labels),
       bar: external_exports.strictObject(SHAPES.bar),
+      usage: external_exports.strictObject(SHAPES.usage),
+      clock: external_exports.strictObject(SHAPES.clock),
       colours: external_exports.strictObject(SHAPES.colours),
       project: external_exports.strictObject(SHAPES.project),
       git: external_exports.strictObject(SHAPES.git),
@@ -25215,6 +25531,8 @@ var init_statusline = __esm({
       bands: { warnAt: 70, criticalAt: 90 },
       labels: { fiveHour: "5h", sevenDay: "Wk" },
       bar: { width: 10, filled: "\u2588", empty: "\u2591" },
+      usage: { value: "used", bar: true, compact: false, resetLabel: false, modelScoped: false, timeFormat: "relative", threshold: 0, sevenDayThreshold: 0 },
+      clock: { hourCycle: "auto", seconds: false },
       colours: {
         context: "green",
         usage: "green",
@@ -29227,11 +29545,59 @@ function hasDesktopSession() {
     const result = (0, import_node_child_process2.spawnSync)("launchctl", ["managername"], { encoding: "utf8" });
     return result.status === 0 && result.stdout.trim() === MACOS_GUI_SESSION_MANAGER;
   }
+  return hasDisplayServer();
+}
+function hasDisplayServer() {
   if (process.platform === "win32") {
     return false;
   }
   return (process.env.DISPLAY ?? "") !== "" || (process.env.WAYLAND_DISPLAY ?? "") !== "";
 }
+async function hasDesktopSessionAsync() {
+  if (process.platform !== "darwin") {
+    return hasDisplayServer();
+  }
+  return await new Promise((resolve2) => {
+    (0, import_node_child_process2.execFile)("launchctl", ["managername"], { encoding: "utf8" }, (error63, stdout2) => {
+      resolve2(error63 === null && stdout2.trim() === MACOS_GUI_SESSION_MANAGER);
+    });
+  });
+}
+async function runCredentialCommand(argv, options) {
+  const [command, ...args] = argv;
+  return await new Promise((resolve2) => {
+    const child = (0, import_node_child_process2.spawn)(command, args, { stdio: options.interactive ? ["inherit", "pipe", "inherit"] : ["ignore", "pipe", "pipe"] });
+    let stdout2 = "";
+    let stderr = "";
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill();
+    }, options.timeoutMs);
+    let settled = false;
+    const settle2 = (result) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timer);
+        resolve2(result);
+      }
+    };
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk2) => {
+      stdout2 += chunk2;
+    });
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk2) => {
+      stderr += chunk2;
+    });
+    child.once("error", (error63) => {
+      settle2({ status: null, stdout: "", stderr: error63.message, timedOut: false });
+    });
+    child.once("close", (status) => {
+      settle2(timedOut ? { status: null, stdout: "", stderr: "", timedOut: true } : { status, stdout: stdout2, stderr: options.interactive ? "" : stderr, timedOut: false });
+    });
+  });
+}
 function resolveGitBranch(run, cwd) {
   const result = run.run("git", ["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"]);
   if (result.status !== 0) {
@@ -29428,7 +29794,7 @@ function realResolveClaudeBinary(isOwnBinary) {
 function realInstalledClaudeVersions() {
   return installedVersions(listVersionsDir(defaultVersionsDir()));
 }
-var import_node_child_process2, import_node_crypto4, import_node_fs3, import_node_os2, import_node_path9, import_node_sea, realFsPort, OWNER_ONLY_DIR_MODE, OWNER_ONLY_FILE_MODE, PERMISSION_BITS, realFarmFs, INT32_BYTE_LENGTH, KEY_POLL_MS, CTRL_C_BYTE, realHoldPort, LINE_FEED, UTF8_CONTINUATION_MASK, UTF8_CONTINUATION_BITS, PS_TIMEOUT_MS, realRunPort, MACOS_GUI_SESSION_MANAGER, realCredentialPort, SOCKET_PERMISSION_BITS, realHeadroomSocketTrust, realSpawnPort, realProcPort, realLogPort, EXECUTE_BITS_MASK, WINDOWS_DEFAULT_PATHEXT;
+var import_node_child_process2, import_node_crypto4, import_node_fs3, import_node_os2, import_node_path9, import_node_sea, realFsPort, OWNER_ONLY_DIR_MODE, OWNER_ONLY_FILE_MODE, PERMISSION_BITS, realFarmFs, INT32_BYTE_LENGTH, KEY_POLL_MS, CTRL_C_BYTE, realHoldPort, LINE_FEED, UTF8_CONTINUATION_MASK, UTF8_CONTINUATION_BITS, PS_TIMEOUT_MS, realRunPort, MACOS_GUI_SESSION_MANAGER, realCredentialPort, realAsyncCredentialPort, SOCKET_PERMISSION_BITS, realHeadroomSocketTrust, realSpawnPort, realProcPort, realLogPort, EXECUTE_BITS_MASK, WINDOWS_DEFAULT_PATHEXT;
 var init_realPorts = __esm({
   "src/realPorts.ts"() {
     "use strict";
@@ -29644,6 +30010,11 @@ var init_realPorts = __esm({
       },
       personPresent: () => process.stdin.isTTY || hasDesktopSession()
     };
+    realAsyncCredentialPort = {
+      readSecretFile: (filePath) => realCredentialPort.readSecretFile(filePath),
+      runCommand: runCredentialCommand,
+      personPresent: async () => process.stdin.isTTY || await hasDesktopSessionAsync()
+    };
     SOCKET_PERMISSION_BITS = 4095;
     realHeadroomSocketTrust = {
       platform: process.platform,
@@ -31658,17 +32029,17 @@ var require_picomatch = __commonJS({
       }
       const opts = options || {};
       const posix = opts.windows;
-      const regex = isState ? picomatch4.compileRe(glob, options) : picomatch4.makeRe(glob, options, false, true);
-      const state = regex.state;
-      delete regex.state;
+      const regex2 = isState ? picomatch4.compileRe(glob, options) : picomatch4.makeRe(glob, options, false, true);
+      const state = regex2.state;
+      delete regex2.state;
       let isIgnored = () => false;
       if (opts.ignore) {
         const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
         isIgnored = picomatch4(opts.ignore, ignoreOpts, returnState);
       }
       const matcher = (input2, returnObject = false) => {
-        const { isMatch, match, output: output2 } = picomatch4.test(input2, regex, options, { glob, posix });
-        const result = { glob, state, regex, posix, input: input2, output: output2, match, isMatch };
+        const { isMatch, match, output: output2 } = picomatch4.test(input2, regex2, options, { glob, posix });
+        const result = { glob, state, regex: regex2, posix, input: input2, output: output2, match, isMatch };
         if (typeof opts.onResult === "function") {
           opts.onResult(result);
         }
@@ -31693,7 +32064,7 @@ var require_picomatch = __commonJS({
       }
       return matcher;
     };
-    picomatch4.test = (input2, regex, options, { glob, posix } = {}) => {
+    picomatch4.test = (input2, regex2, options, { glob, posix } = {}) => {
       if (typeof input2 !== "string") {
         throw new TypeError("Expected input to be a string");
       }
@@ -31710,16 +32081,16 @@ var require_picomatch = __commonJS({
       }
       if (match === false || opts.capture === true) {
         if (opts.matchBase === true || opts.basename === true) {
-          match = picomatch4.matchBase(input2, regex, options, posix);
+          match = picomatch4.matchBase(input2, regex2, options, posix);
         } else {
-          match = regex.exec(output2);
+          match = regex2.exec(output2);
         }
       }
       return { isMatch: Boolean(match), match, output: output2 };
     };
     picomatch4.matchBase = (input2, glob, options, posix = options && options.windows) => {
-      const regex = glob instanceof RegExp ? glob : picomatch4.makeRe(glob, options);
-      return regex.test(utils.basename(input2, { windows: posix }));
+      const regex2 = glob instanceof RegExp ? glob : picomatch4.makeRe(glob, options);
+      return regex2.test(utils.basename(input2, { windows: posix }));
     };
     picomatch4.isMatch = (str, patterns, options) => picomatch4(patterns, options)(str);
     picomatch4.parse = (pattern, options) => {
@@ -31738,11 +32109,11 @@ var require_picomatch = __commonJS({
       if (state && state.negated === true) {
         source = `^(?!${source}).*$`;
       }
-      const regex = picomatch4.toRegex(source, options);
+      const regex2 = picomatch4.toRegex(source, options);
       if (returnState === true) {
-        regex.state = state;
+        regex2.state = state;
       }
-      return regex;
+      return regex2;
     };
     picomatch4.makeRe = (input2, options = {}, returnOutput = false, returnState = false) => {
       if (!input2 || typeof input2 !== "string") {
@@ -35047,51 +35418,87 @@ function unpackKeyringToken(raw) {
   }
   return trimmed;
 }
-function trySource(source, params) {
-  const none = (reason, warn = false) => ({ ok: false, reason, warn });
+function declined(reason, warn = false) {
+  return { ok: false, reason, warn };
+}
+function isCommandBacked(source) {
+  return "command" in source || "op" in source || "keychain" in source;
+}
+function immediateOutcome(source, params) {
   if ("env" in source) {
     const value2 = params.env[source.env];
-    return value2 === void 0 || value2 === "" ? none("is unset or empty") : { ok: true, token: unpackKeyringToken(value2) };
+    return value2 === void 0 || value2 === "" ? declined("is unset or empty") : { ok: true, token: unpackKeyringToken(value2) };
   }
   if ("literal" in source) {
     return { ok: true, token: source.literal };
   }
-  if ("file" in source) {
-    const read = params.port.readSecretFile(source.file);
-    if (!read.found) {
-      return none("does not exist");
-    }
-    if (read.mode !== void 0 && (read.mode & GROUP_OTHER_PERMISSION_BITS) !== 0) {
-      return none(
-        `is readable or writable by group or others (mode ${(read.mode & PERMISSION_BITS2).toString(OCTAL_RADIX2)}); run \`chmod 600 ${source.file}\``,
-        true
-      );
-    }
-    const token2 = unpackKeyringToken(read.content.trim());
-    return token2 === "" ? none("is empty") : { ok: true, token: token2 };
+  const read = params.port.readSecretFile(source.file);
+  if (!read.found) {
+    return declined("does not exist");
   }
-  const argv = commandArgv(source);
-  const interactive = isInteractiveSource(source, params.env);
-  if (interactive && !params.port.personPresent()) {
-    return none("needs a person to approve it, but there is no terminal or desktop session");
+  if (read.mode !== void 0 && (read.mode & GROUP_OTHER_PERMISSION_BITS) !== 0) {
+    return declined(
+      `is readable or writable by group or others (mode ${(read.mode & PERMISSION_BITS2).toString(OCTAL_RADIX2)}); run \`chmod 600 ${source.file}\``,
+      true
+    );
   }
-  const timeoutMs = source.timeoutMs ?? (interactive ? CREDENTIAL_INTERACTIVE_TIMEOUT_MS : CREDENTIAL_COMMAND_TIMEOUT_MS);
-  const result = params.port.runCommand(argv, { timeoutMs, interactive });
+  const token = unpackKeyringToken(read.content.trim());
+  return token === "" ? declined("is empty") : { ok: true, token };
+}
+function commandRunOf(source, env) {
+  const interactive = isInteractiveSource(source, env);
+  return { argv: commandArgv(source), interactive, timeoutMs: source.timeoutMs ?? (interactive ? CREDENTIAL_INTERACTIVE_TIMEOUT_MS : CREDENTIAL_COMMAND_TIMEOUT_MS) };
+}
+function commandOutcome(result, timeoutMs) {
   if (result.timedOut) {
-    return none(`timed out after ${String(timeoutMs)}ms`);
+    return declined(`timed out after ${String(timeoutMs)}ms`);
   }
   if (result.status !== 0) {
     const stderr = result.stderr.trim();
     const outcome = result.status === null ? "could not be run or was killed by a signal" : `exited with status ${String(result.status)}`;
-    return none(`${outcome}${stderr === "" ? "" : `: ${stderr}`}`);
+    return declined(`${outcome}${stderr === "" ? "" : `: ${stderr}`}`);
   }
   const token = unpackKeyringToken(result.stdout.trim());
-  return token === "" ? none("printed no token") : { ok: true, token };
+  return token === "" ? declined("printed no token") : { ok: true, token };
+}
+function trySource(source, params) {
+  if (!isCommandBacked(source)) {
+    return immediateOutcome(source, params);
+  }
+  const run = commandRunOf(source, params.env);
+  if (run.interactive && !params.port.personPresent()) {
+    return declined(NO_PERSON_REASON);
+  }
+  return commandOutcome(params.port.runCommand(run.argv, { timeoutMs: run.timeoutMs, interactive: run.interactive }), run.timeoutMs);
+}
+async function trySourceAsync(source, params) {
+  if (!isCommandBacked(source)) {
+    return immediateOutcome(source, params);
+  }
+  const run = commandRunOf(source, params.env);
+  if (run.interactive && !await params.port.personPresent()) {
+    return declined(NO_PERSON_REASON);
+  }
+  return commandOutcome(await params.port.runCommand(run.argv, { timeoutMs: run.timeoutMs, interactive: run.interactive }), run.timeoutMs);
 }
 function warmCommandFor(subject) {
   const [kind, name] = subject.split(" ");
   return kind === "provider" ? `agent-shim credential warm --provider ${name ?? ""}` : `agent-shim credential warm ${name ?? ""}`;
 }
+function cachedResolution(target, entry) {
+  return { ok: true, credential: { target, token: entry.token, source: entry.source, warnings: [], cachedAt: entry.fetchedAt } };
+}
+function liveResolution(target, token, source, warnings) {
+  return { ok: true, credential: { target, token, source, warnings } };
+}
+function unresolved(subject, cacheBlock, attempts) {
+  const hint = cacheBlock === void 0 ? "" : `; fill the cache from a terminal with \`${warmCommandFor(subject)}\``;
+  return { ok: false, message: `agent-shim: ${subject} has no usable credential: ${attempts.join("; ")}${hint}` };
+}
+function declinedLine(source, outcome, subject) {
+  const attempt = `${describeSource(source)} ${outcome.reason}`;
+  return { attempt, warning: outcome.warn ? `agent-shim: ${subject}: skipped ${attempt}` : void 0 };
+}
 function resolveCredential(params) {
   const target = params.credential.target ?? "bearer";
   const cacheBlock = params.credential.cache;
@@ -35100,7 +35507,7 @@ function resolveCredential(params) {
   if (cacheBlock !== void 0 && cache !== void 0 && store !== void 0 && params.refresh !== true) {
     const entry = cache.port.read(store, params.subject);
     if (entry !== void 0 && isFresh(entry, cacheBlock, cache.now())) {
-      return { ok: true, credential: { target, token: entry.token, source: entry.source, warnings: [], cachedAt: entry.fetchedAt } };
+      return cachedResolution(target, entry);
     }
   }
   const attempts = [];
@@ -35111,16 +35518,59 @@ function resolveCredential(params) {
       if (cache !== void 0 && store !== void 0) {
         cache.port.write(store, params.subject, { token: outcome.token, fetchedAt: cache.now(), source });
       }
-      return { ok: true, credential: { target, token: outcome.token, source, warnings } };
+      return liveResolution(target, outcome.token, source, warnings);
     }
-    const line = `${describeSource(source)} ${outcome.reason}`;
-    attempts.push(line);
-    if (outcome.warn) {
-      warnings.push(`agent-shim: ${params.subject}: skipped ${line}`);
+    const line = declinedLine(source, outcome, params.subject);
+    attempts.push(line.attempt);
+    if (line.warning !== void 0) {
+      warnings.push(line.warning);
     }
   }
-  const hint = cacheBlock === void 0 ? "" : `; fill the cache from a terminal with \`${warmCommandFor(params.subject)}\``;
-  return { ok: false, message: `agent-shim: ${params.subject} has no usable credential: ${attempts.join("; ")}${hint}` };
+  return unresolved(params.subject, cacheBlock, attempts);
+}
+async function resolveCredentialAsync(params) {
+  const target = params.credential.target ?? "bearer";
+  const cacheBlock = params.credential.cache;
+  const cache = cacheBlock === void 0 ? void 0 : params.port.cache;
+  const store = cacheBlock === void 0 || cache === void 0 ? void 0 : effectiveStore(cacheBlock, cache.platform);
+  if (cacheBlock !== void 0 && cache !== void 0 && store !== void 0 && params.refresh !== true) {
+    const entry = await cache.port.read(store, params.subject);
+    if (entry !== void 0 && isFresh(entry, cacheBlock, cache.now())) {
+      return cachedResolution(target, entry);
+    }
+  }
+  const attempts = [];
+  const warnings = [];
+  for (const source of params.credential.sources) {
+    const outcome = await trySourceAsync(source, params);
+    if (outcome.ok) {
+      if (cache !== void 0 && store !== void 0) {
+        await cache.port.write(store, params.subject, { token: outcome.token, fetchedAt: cache.now(), source });
+      }
+      return liveResolution(target, outcome.token, source, warnings);
+    }
+    const line = declinedLine(source, outcome, params.subject);
+    attempts.push(line.attempt);
+    if (line.warning !== void 0) {
+      warnings.push(line.warning);
+    }
+  }
+  return unresolved(params.subject, cacheBlock, attempts);
+}
+function shareInFlightResolutions(resolve2) {
+  const inFlight = /* @__PURE__ */ new Map();
+  return async (params) => {
+    const key = JSON.stringify([params.subject, params.credential, params.refresh === true]);
+    const running = inFlight.get(key);
+    if (running !== void 0) {
+      return await running;
+    }
+    const started = resolve2(params).finally(() => {
+      inFlight.delete(key);
+    });
+    inFlight.set(key, started);
+    return await started;
+  };
 }
 function credentialVariables(target, token) {
   return {
@@ -35129,7 +35579,7 @@ function credentialVariables(target, token) {
     CLAUDE_CODE_OAUTH_TOKEN: target === "oauthToken" ? token : void 0
   };
 }
-var CREDENTIAL_UNAVAILABLE_EXIT, CREDENTIAL_COMMAND_TIMEOUT_MS, CREDENTIAL_INTERACTIVE_TIMEOUT_MS, GROUP_OTHER_PERMISSION_BITS, PERMISSION_BITS2, OCTAL_RADIX2, GO_KEYRING_BASE64_PREFIX;
+var CREDENTIAL_UNAVAILABLE_EXIT, CREDENTIAL_COMMAND_TIMEOUT_MS, CREDENTIAL_INTERACTIVE_TIMEOUT_MS, GROUP_OTHER_PERMISSION_BITS, PERMISSION_BITS2, OCTAL_RADIX2, GO_KEYRING_BASE64_PREFIX, NO_PERSON_REASON;
 var init_credential = __esm({
   "src/credential.ts"() {
     "use strict";
@@ -35141,6 +35591,7 @@ var init_credential = __esm({
     PERMISSION_BITS2 = 511;
     OCTAL_RADIX2 = 8;
     GO_KEYRING_BASE64_PREFIX = "go-keyring-base64:";
+    NO_PERSON_REASON = "needs a person to approve it, but there is no terminal or desktop session";
   }
 });
 
@@ -36315,7 +36766,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "claude-use",
-      version: "11.54.1",
+      version: "11.56.0",
       description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
       license: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -36373,6 +36824,7 @@ var init_package = __esm({
         commander: "^15.0.0",
         cosmiconfig: "^10.0.1",
         picomatch: "^4.0.7",
+        "string-width": "8.3.0",
         trilean: "1.7.1",
         undici: "7.29.1",
         zod: "^4.6.1"
@@ -37751,6 +38203,30 @@ function security(args, stdin2) {
   const result = (0, import_node_child_process3.spawnSync)("security", args, { encoding: "utf8", ...stdin2 === void 0 ? {} : { input: stdin2 }, stdio: ["pipe", "pipe", "ignore"] });
   return { status: result.status, stdout: result.stdout };
 }
+async function securityAsync(args, stdin2) {
+  return await new Promise((resolve2) => {
+    const child = (0, import_node_child_process3.spawn)("security", args, { stdio: ["pipe", "pipe", "ignore"] });
+    let stdout2 = "";
+    let settled = false;
+    const settle2 = (status) => {
+      if (!settled) {
+        settled = true;
+        resolve2({ status, stdout: stdout2 });
+      }
+    };
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk2) => {
+      stdout2 += chunk2;
+    });
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(stdin2);
+    child.once("error", () => {
+      settle2(null);
+    });
+    child.once("close", settle2);
+  });
+}
 function createRealCredentialCache(root) {
   const dir = import_node_path29.default.join(root, "credential-cache");
   const filePath = (owner) => import_node_path29.default.join(dir, cacheFileNameFor(owner));
@@ -37799,6 +38275,46 @@ function createRealCredentialCache(root) {
 function realCredentialCacheEnv(paths) {
   return { port: createRealCredentialCache(paths.root), platform: process.platform, now: () => Date.now() };
 }
+function createAsyncRealCredentialCache(root) {
+  const dir = import_node_path29.default.join(root, "credential-cache");
+  const filePath = (owner) => import_node_path29.default.join(dir, cacheFileNameFor(owner));
+  return {
+    async read(store, owner) {
+      if (store === "file") {
+        try {
+          return parseEntry(await import_node_fs9.default.promises.readFile(filePath(owner), "utf8"));
+        } catch {
+          return void 0;
+        }
+      }
+      requireKeychain();
+      const result = await securityAsync(["find-generic-password", "-s", KEYCHAIN_CACHE_SERVICE, "-a", owner, "-w"]);
+      return result.status === 0 ? parseEntry(Buffer.from(result.stdout.trim(), "base64").toString("utf8")) : void 0;
+    },
+    async write(store, owner, entry) {
+      const serialised = JSON.stringify(entry);
+      if (store === "file") {
+        await import_node_fs9.default.promises.mkdir(dir, { recursive: true, mode: CACHE_DIR_MODE });
+        await import_node_fs9.default.promises.chmod(dir, CACHE_DIR_MODE);
+        const target = filePath(owner);
+        const temp = `${target}.${String(process.pid)}.tmp`;
+        await import_node_fs9.default.promises.writeFile(temp, serialised, { mode: CACHE_FILE_MODE });
+        await import_node_fs9.default.promises.rename(temp, target);
+        return;
+      }
+      requireKeychain();
+      const encoded = Buffer.from(serialised, "utf8").toString("base64");
+      const result = await securityAsync(["-i"], `add-generic-password -U -s ${KEYCHAIN_CACHE_SERVICE} -a ${JSON.stringify(owner)} -w ${encoded}
+`);
+      if (result.status !== 0) {
+        throw new Error(`could not write the keychain credential cache for ${owner}`);
+      }
+    }
+  };
+}
+function realAsyncCredentialCacheEnv(paths) {
+  return { port: createAsyncRealCredentialCache(paths.root), platform: process.platform, now: () => Date.now() };
+}
 var import_node_child_process3, import_node_fs9, import_node_path29, KEYCHAIN_CACHE_SERVICE, CACHE_DIR_MODE, CACHE_FILE_MODE;
 var init_realCredentialCache = __esm({
   "src/realCredentialCache.ts"() {
@@ -62222,10 +62738,10 @@ var require_connection = __commonJS({
       });
       return controller;
     }
-    function closeWebSocketConnection(object3, code, reason, validate2 = false) {
+    function closeWebSocketConnection(object3, code, reason, validate3 = false) {
       code ??= null;
       reason ??= "";
-      if (validate2) validateCloseCodeAndReason(code, reason);
+      if (validate3) validateCloseCodeAndReason(code, reason);
       if (isClosed(object3.readyState) || isClosing(object3.readyState)) {
       } else if (!isEstablished(object3.readyState)) {
         failWebsocketConnection(object3);
@@ -68358,13 +68874,13 @@ function resolveLaunch(params) {
     environment
   };
 }
-function runLaunchPlan(plan, spawn8) {
+function runLaunchPlan(plan, spawn9) {
   try {
     if (plan.hold() === "cancelled") {
       return LAUNCH_CANCELLED_EXIT;
     }
     plan.markChildStarted();
-    const result = spawn8.spawnSync(plan.bin, plan.args, { stdio: "inherit", env: plan.env });
+    const result = spawn9.spawnSync(plan.bin, plan.args, { stdio: "inherit", env: plan.env });
     if (result.error !== void 0) {
       throw result.error;
     }
@@ -68852,7 +69368,7 @@ function createQuotaRefresher(deps) {
   const fetchNow = async (identity, provider, lookup, adapter) => {
     const key = `${identity}\0${provider}`;
     try {
-      const apiKey = lookup.apiKey();
+      const apiKey = await lookup.apiKey();
       const quota = await adapter.fetch(apiKey, deps.http, AbortSignal.timeout(QUOTA_REQUEST_TIMEOUT_MS), deps.now());
       if (!deps.record(identity, provider, quota)) {
         return { status: "no-usage" };
@@ -68922,8 +69438,8 @@ function createProviderLookup(ports) {
     }
     return {
       baseUrl,
-      apiKey: () => {
-        const resolution = resolveCredential({ credential: isRouterProvider(definition) ? { sources: [] } : definition.credential, env: ports.env, port: ports.credentials, subject: `provider ${name}` });
+      apiKey: async () => {
+        const resolution = await resolveCredentialAsync({ credential: isRouterProvider(definition) ? { sources: [] } : definition.credential, env: ports.env, port: ports.credentials, subject: `provider ${name}` });
         if (!resolution.ok) {
           throw new Error(resolution.message);
         }
@@ -104320,8 +104836,8 @@ var require_keyword = __commonJS({
       var _a4;
       const { gen, keyword, schema, parentSchema, $data, it: it2 } = cxt;
       checkAsyncKeyword(it2, def);
-      const validate2 = !$data && def.compile ? def.compile.call(it2.self, schema, parentSchema, it2) : def.validate;
-      const validateRef = useKeyword(gen, keyword, validate2);
+      const validate3 = !$data && def.compile ? def.compile.call(it2.self, schema, parentSchema, it2) : def.validate;
+      const validateRef = useKeyword(gen, keyword, validate3);
       const valid = gen.let("valid");
       cxt.block$data(valid, validateKeyword);
       cxt.ok((_a4 = def.valid) !== null && _a4 !== void 0 ? _a4 : valid);
@@ -105394,28 +105910,28 @@ var require_compile = __commonJS({
         if (this.opts.code.process)
           sourceCode = this.opts.code.process(sourceCode, sch);
         const makeValidate = new Function(`${names_1.default.self}`, `${names_1.default.scope}`, sourceCode);
-        const validate2 = makeValidate(this, this.scope.get());
-        this.scope.value(validateName, { ref: validate2 });
-        validate2.errors = null;
-        validate2.schema = sch.schema;
-        validate2.schemaEnv = sch;
+        const validate3 = makeValidate(this, this.scope.get());
+        this.scope.value(validateName, { ref: validate3 });
+        validate3.errors = null;
+        validate3.schema = sch.schema;
+        validate3.schemaEnv = sch;
         if (sch.$async)
-          validate2.$async = true;
+          validate3.$async = true;
         if (this.opts.code.source === true) {
-          validate2.source = { validateName, validateCode, scopeValues: gen._values };
+          validate3.source = { validateName, validateCode, scopeValues: gen._values };
         }
         if (this.opts.unevaluated) {
           const { props, items } = schemaCxt;
-          validate2.evaluated = {
+          validate3.evaluated = {
             props: props instanceof codegen_1.Name ? void 0 : props,
             items: items instanceof codegen_1.Name ? void 0 : items,
             dynamicProps: props instanceof codegen_1.Name,
             dynamicItems: items instanceof codegen_1.Name
           };
-          if (validate2.source)
-            validate2.source.evaluated = (0, codegen_1.stringify)(validate2.evaluated);
+          if (validate3.source)
+            validate3.source.evaluated = (0, codegen_1.stringify)(validate3.evaluated);
         }
-        sch.validate = validate2;
+        sch.validate = validate3;
         return sch;
       } catch (e14) {
         delete sch.validate;
@@ -107097,10 +107613,10 @@ var require_core2 = __commonJS({
         }
         return metaSchema;
       }
-      _removeAllSchemas(schemas, regex) {
+      _removeAllSchemas(schemas, regex2) {
         for (const keyRef in schemas) {
           const sch = schemas[keyRef];
-          if (!regex || regex.test(keyRef)) {
+          if (!regex2 || regex2.test(keyRef)) {
             if (typeof sch == "string") {
               delete schemas[keyRef];
             } else if (sch && !sch.meta) {
@@ -109338,8 +109854,8 @@ var require_formats = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.formatNames = exports2.fastFormats = exports2.fullFormats = void 0;
-    function fmtDef(validate2, compare) {
-      return { validate: validate2, compare };
+    function fmtDef(validate3, compare) {
+      return { validate: validate3, compare };
     }
     exports2.fullFormats = {
       // date: http://tools.ietf.org/html/rfc3339#section-5.6
@@ -109363,7 +109879,7 @@ var require_formats = __commonJS({
       // optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html
       ipv4: /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/,
       ipv6: /^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i,
-      regex,
+      regex: regex2,
       // uuid: http://tools.ietf.org/html/rfc4122
       uuid: /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i,
       // JSON-pointer: https://tools.ietf.org/html/rfc6901
@@ -109522,7 +110038,7 @@ var require_formats = __commonJS({
       return true;
     }
     var Z_ANCHOR = /[^\\]\\Z/;
-    function regex(str) {
+    function regex2(str) {
       if (Z_ANCHOR.test(str))
         return false;
       try {
@@ -111393,9 +111909,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
     if (typeof fn2 === "function") {
       option.default(defaultValue).argParser(fn2);
     } else if (fn2 instanceof RegExp) {
-      const regex = fn2;
+      const regex2 = fn2;
       fn2 = (val, def) => {
-        const m10 = regex.exec(val);
+        const m10 = regex2.exec(val);
         return m10 ? m10[0] : def;
       };
       option.default(defaultValue).argParser(fn2);
@@ -113068,7 +113584,7 @@ var getCodePointsLength = /* @__PURE__ */ (() => {
     return input2.length - surrogatePairsNr;
   };
 })();
-var isFullWidth = (x) => {
+var isFullWidth2 = (x) => {
   return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
 };
 var isWideNotCJKTNotEmoji = (x) => {
@@ -113120,7 +113636,7 @@ var getStringTruncatedWidth = (input2, truncationOptions = {}, widthOptions = {}
       lengthExtra = 0;
       for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
         const codePoint = char.codePointAt(0) || 0;
-        if (isFullWidth(codePoint)) {
+        if (isFullWidth2(codePoint)) {
           widthExtra = FULL_WIDTH_WIDTH;
         } else if (isWideNotCJKTNotEmoji(codePoint)) {
           widthExtra = WIDE_WIDTH;
@@ -121311,7 +121827,7 @@ function runDoctor(params) {
   const push = (section, severity, message, subject) => {
     findings.push({ section, severity, message, ...subject === void 0 ? {} : { subject } });
   };
-  const validate2 = (schema, input2, section, subject) => {
+  const validate3 = (schema, input2, section, subject) => {
     const validated2 = validateJson(schema, input2);
     if (validated2.ok && validated2.warning !== void 0) {
       push(section, "warn", validated2.warning, subject);
@@ -121357,7 +121873,7 @@ function runDoctor(params) {
   pushLegacyName(push, params);
   const profileSources = /* @__PURE__ */ new Map();
   for (const entry of params.configProfiles) {
-    const validated2 = validate2(ConfigProfileSchema, entry, "config-profile", entry.name);
+    const validated2 = validate3(ConfigProfileSchema, entry, "config-profile", entry.name);
     if (!validated2.ok) {
       push("config-profile", "fail", validated2.message, entry.name);
       continue;
@@ -121379,7 +121895,7 @@ function runDoctor(params) {
   const validProfileNames = new Set(profileSources.keys());
   const validIdentityNames = /* @__PURE__ */ new Set();
   for (const entry of params.identities) {
-    const validated2 = validate2(IdentitySchema, entry, "identity", entry.name);
+    const validated2 = validate3(IdentitySchema, entry, "identity", entry.name);
     if (!validated2.ok) {
       push("identity", "fail", validated2.message, entry.name);
       continue;
@@ -121469,7 +121985,7 @@ function runDoctor(params) {
   if (params.directoryRules.raw === void 0) {
     push("directory-rules", "pass", "No directory-rules.json configured.");
   } else {
-    const validated2 = validate2(DirectoryRulesSchema, params.directoryRules, "directory-rules");
+    const validated2 = validate3(DirectoryRulesSchema, params.directoryRules, "directory-rules");
     if (!validated2.ok) {
       push("directory-rules", "fail", validated2.message);
     } else {
@@ -121494,7 +122010,7 @@ function runDoctor(params) {
   if (params.globalConfig.raw === void 0) {
     push("global-config", "pass", "No config.json configured.");
   } else {
-    const validated2 = validate2(GlobalConfigSchema, params.globalConfig, "global-config");
+    const validated2 = validate3(GlobalConfigSchema, params.globalConfig, "global-config");
     if (!validated2.ok) {
       push("global-config", "fail", validated2.message);
     } else {
@@ -121525,7 +122041,7 @@ function runDoctor(params) {
   if (params.categoriesLocal.raw === void 0) {
     push("categories-local", "pass", "No categories.local.json configured.");
   } else {
-    const validated2 = validate2(CategoryClassificationOverlaySchema, params.categoriesLocal, "categories-local");
+    const validated2 = validate3(CategoryClassificationOverlaySchema, params.categoriesLocal, "categories-local");
     push(
       "categories-local",
       validated2.ok ? "pass" : "fail",
@@ -129019,8 +129535,8 @@ function getParamRegexp(segment, unnamedStart = 0) {
     _s2 += segment[j10];
   }
   [_s2, _i2] = replaceSegmentWildcards(_s2, _i2);
-  const regex = _s2.replace(/:([\w-]+)(?:\(([^)]*)\))?/g, (_, id2, p) => `(?<${toGroupName(id2)}>${p || "[^/]+"})`).replace(/\((?![?<])/g, () => `(?<${toUnnamedGroupKey(_i2++)}>`).replace(/\uFFFE(.)/g, (_, c10) => /[.*+?^${}()|[\]\\]/.test(c10) ? `\\${c10}` : c10);
-  return [new RegExp(`^${regex}$`), _i2];
+  const regex2 = _s2.replace(/:([\w-]+)(?:\(([^)]*)\))?/g, (_, id2, p) => `(?<${toGroupName(id2)}>${p || "[^/]+"})`).replace(/\((?![?<])/g, () => `(?<${toUnnamedGroupKey(_i2++)}>`).replace(/\uFFFE(.)/g, (_, c10) => /[.*+?^${}()|[\]\\]/.test(c10) ? `\\${c10}` : c10);
+  return [new RegExp(`^${regex2}$`), _i2];
 }
 function findRoute(ctx, method = "", path68, opts) {
   if (opts?.normalize) path68 = normalizePath(path68);
@@ -130720,13 +131236,8 @@ function rcFanoutOnDoorHub(fanout, hub) {
 }
 
 // src/frontdoor/quotaExpiringEvents.ts
+init_pick();
 init_schema2();
-var MS_PER_HOUR5 = 36e5;
-var MS_PER_DAY4 = 864e5;
-var FIVE_HOUR_WINDOW_HOURS = 5;
-var SEVEN_DAY_WINDOW_DAYS = 7;
-var FIVE_HOUR_WINDOW_MS2 = FIVE_HOUR_WINDOW_HOURS * MS_PER_HOUR5;
-var SEVEN_DAY_WINDOW_MS2 = SEVEN_DAY_WINDOW_DAYS * MS_PER_DAY4;
 var FINAL_SPAN_DENOMINATOR = 30;
 var QUOTA_EXPIRING_WINDOW_FRACTION = 1 / FINAL_SPAN_DENOMINATOR;
 function createQuotaExpiringPublisher(hub, deps) {
@@ -130746,11 +131257,11 @@ function createQuotaExpiringPublisher(hub, deps) {
       const unified = snapshot.providers[provider]?.rateLimit?.unified;
       const fiveHour = unified?.fiveHour;
       if (fiveHour?.utilization !== void 0 && fiveHour.resetsAt !== void 0) {
-        views.push({ provider, view: { window: "fiveHour", spanMs: FIVE_HOUR_WINDOW_MS2, utilization: fiveHour.utilization, resetsAtMs: Date.parse(fiveHour.resetsAt) } });
+        views.push({ provider, view: { window: "fiveHour", spanMs: FIVE_HOUR_WINDOW_MS, utilization: fiveHour.utilization, resetsAtMs: Date.parse(fiveHour.resetsAt) } });
       }
       const sevenDay = unified?.sevenDay;
       if (sevenDay?.utilization !== void 0 && sevenDay.resetsAt !== void 0) {
-        views.push({ provider, view: { window: "sevenDay", spanMs: SEVEN_DAY_WINDOW_MS2, utilization: sevenDay.utilization, resetsAtMs: Date.parse(sevenDay.resetsAt) } });
+        views.push({ provider, view: { window: "sevenDay", spanMs: SEVEN_DAY_WINDOW_MS, utilization: sevenDay.utilization, resetsAtMs: Date.parse(sevenDay.resetsAt) } });
       }
     }
     return views;
@@ -131567,10 +132078,10 @@ function quotaHeaders(upstream) {
 var EXHAUSTED_PERCENT = 100;
 var FULL_PERCENT = 100;
 var MINUTES_PER_HOUR3 = 60;
-var FIVE_HOUR_WINDOW_HOURS2 = 5;
+var FIVE_HOUR_WINDOW_HOURS = 5;
 var HOURS_PER_DAY7 = 24;
 var DAYS_PER_WEEK3 = 7;
-var FIVE_HOUR_MINUTES = FIVE_HOUR_WINDOW_HOURS2 * MINUTES_PER_HOUR3;
+var FIVE_HOUR_MINUTES = FIVE_HOUR_WINDOW_HOURS * MINUTES_PER_HOUR3;
 var SEVEN_DAY_MINUTES = DAYS_PER_WEEK3 * HOURS_PER_DAY7 * MINUTES_PER_HOUR3;
 function windowReadings(upstream, exhausted, quotaError) {
   let fiveHour;
@@ -132434,7 +132945,7 @@ function createAntigravityRoute(ports) {
         body: JSON.stringify({ type: "error", error: { type: "not_found_error", message: "no provider specified in path" } })
       };
     }
-    const lookup = ports.loadProvider(providerName);
+    const lookup = await ports.loadProvider(providerName);
     if (!lookup.ok) {
       return {
         status: lookup.status,
@@ -132948,6 +133459,7 @@ function resolveAccountTarget(model, models) {
 }
 function createProviderRouteResolver(deps) {
   const oauthRoute = createPassthroughRoute("anthropic", { baseUrl: `https://${CONNECT_INTERCEPT_HOST}:${String(HTTPS_PORT)}`, stripPrefix: void 0, headroomUpstream: void 0 });
+  const resolveCredential2 = shareInFlightResolutions(resolveCredentialAsync);
   const antigravityQuotaSources = /* @__PURE__ */ new Map();
   const antigravityRoutingMemory = /* @__PURE__ */ new Map();
   const definesProvider = (name) => {
@@ -132976,7 +133488,7 @@ function createProviderRouteResolver(deps) {
     const source = createCachedAntigravityQuotaSource({
       now: () => Date.now(),
       fetchSummary: async (nowMs) => {
-        const res = resolveCredential({ credential: definition.credential, env: deps.env, port: deps.credentials, subject: `provider ${provider}` });
+        const res = await resolveCredential2({ credential: definition.credential, env: deps.env, port: deps.credentials, subject: `provider ${provider}` });
         if (!res.ok) {
           return void 0;
         }
@@ -133042,8 +133554,8 @@ function createProviderRouteResolver(deps) {
         ok: true,
         route: createAntigravityRouteMount(
           {
-            loadProvider: () => {
-              const res = resolveCredential({
+            loadProvider: async () => {
+              const res = await resolveCredential2({
                 credential: antigravityProvider.credential,
                 env: deps.env,
                 port: deps.credentials,
@@ -133079,7 +133591,7 @@ function createProviderRouteResolver(deps) {
           stripPrefix: `${PROVIDER_PATH_PREFIX}${encodeURIComponent(provider)}`,
           headroomUpstream: directOrigin2(deps.directPort())
         }),
-        { provider, credential: httpProvider.credential, env: deps.env, port: deps.credentials }
+        { provider, credential: httpProvider.credential, env: deps.env, port: deps.credentials, resolve: resolveCredential2 }
       )
     };
   };
@@ -133225,7 +133737,7 @@ function attachingProviderCredential(route, deps) {
     headroomEligible: route.headroomEligible,
     headroomUpstream: route.headroomUpstream,
     serve: async (request7, response) => {
-      const resolution = resolveCredential({ credential: deps.credential, env: deps.env, port: deps.port, subject: `provider ${deps.provider}` });
+      const resolution = await deps.resolve({ credential: deps.credential, env: deps.env, port: deps.port, subject: `provider ${deps.provider}` });
       if (!resolution.ok) {
         response.start(HTTP_STATUS.badGateway, { "Content-Type": "application/json" });
         await response.write(
@@ -136267,7 +136779,7 @@ init_read();
 function createRealQuotaRefresher(params) {
   const { paths, store, log } = params;
   return createQuotaRefresher({
-    lookup: createProviderLookup({ fs: realFsPort, providersDir: paths.providersDir, env: process.env, credentials: realCredentialPort }),
+    lookup: createProviderLookup({ fs: realFsPort, providersDir: paths.providersDir, env: process.env, credentials: realAsyncCredentialPort }),
     http: realQuotaHttpGet,
     readQuota: (identity, provider) => {
       try {
@@ -136385,7 +136897,7 @@ function realFrontDoorSupervisorPorts(paths, respawnGeneration, retire, trackTun
       directPort: () => directPort,
       // The same port (cache included) the launcher resolves a launch's provider with, so the credential the door attaches at the route and the one the launcher handed the child are the same resolution of the same block.
       env: process.env,
-      credentials: { ...realCredentialPort, cache: realCredentialCacheEnv(paths) },
+      credentials: { ...realAsyncCredentialPort, cache: realAsyncCredentialCacheEnv(paths) },
       usageSnapshotOf: (identity) => identity === void 0 ? void 0 : routingSnapshots.get(identity) ?? readUsageSnapshot(realFarmFs, paths.usageSnapshotsDir, identity),
       // An `acct:` model member is served by relaunch: the door leaves a move request for the session's supervisor (found across every pool's registry, since the door does not know which pool launched the session) and answers the request with what is happening. A session nothing supervises gets the message naming the command to run instead.
       observations: (target) => observations.observation(target),
@@ -137111,7 +137623,7 @@ function enrichStatuslinePayload(params) {
         plan = candidatePlan;
       }
     }
-    const providerQuotaWindows = [...scopedState?.quota?.windows ?? []].sort((a10, b) => (a10.periodMs ?? Number.POSITIVE_INFINITY) - (b.periodMs ?? Number.POSITIVE_INFINITY)).map((window) => ({ measures: window.measures, utilization: window.utilization, resetsAt: window.resetsAt }));
+    const providerQuotaWindows = [...scopedState?.quota?.windows ?? []].sort((a10, b) => (a10.periodMs ?? Number.POSITIVE_INFINITY) - (b.periodMs ?? Number.POSITIVE_INFINITY)).map((window) => ({ measures: window.measures, utilization: window.utilization, resetsAt: window.resetsAt, periodMs: window.periodMs }));
     const providerBuckets = Object.fromEntries(
       (scopedState?.quota?.windows ?? []).map((window) => [
         window.measures,
@@ -137221,9 +137733,11 @@ var import_node_os12 = __toESM(require("node:os"), 1);
 var RUN_TIMEOUT_MS = 2e3;
 var RUN_MAX_BUFFER_BYTES = 1048576;
 function realStatuslinePorts(env) {
+  const { locale, timeZone } = Intl.DateTimeFormat().resolvedOptions();
   return {
     env,
     homeDirectory: import_node_os12.default.homedir(),
+    clock: { locale, timeZone },
     readText: (path68) => {
       try {
         return import_node_fs22.default.readFileSync(path68, "utf8");
@@ -137281,11 +137795,33 @@ function realStatuslinePorts(env) {
 init_statusline();
 
 // src/statusline/ansi.ts
+init_string_width();
+init_graphemes();
 var ESCAPE_CHAR_CODE = 27;
 var ESCAPE = String.fromCharCode(ESCAPE_CHAR_CODE);
-var ANSI_REGEX = new RegExp(`${ESCAPE}\\[[0-9;]*[a-zA-Z]`, "g");
+var BELL = "\\u0007";
+var ESCAPE_SEQUENCE_PATTERN = [`${ESCAPE}\\[[0-?]*[ -/]*[@-~]`, `${ESCAPE}\\][^${BELL}${ESCAPE}]*(?:${BELL}|${ESCAPE}\\\\)?`, `${ESCAPE}[@-Z\\\\-_]`].join("|");
+var SPLIT_ON_ESCAPES = new RegExp(`(${ESCAPE_SEQUENCE_PATTERN})`);
 function visibleLength(text4) {
-  return text4.replace(ANSI_REGEX, "").length;
+  return stringWidth(text4);
+}
+function truncateToColumns(text4, columns) {
+  let used = 0;
+  let kept = "";
+  text4.split(SPLIT_ON_ESCAPES).forEach((part, index) => {
+    if (index % 2 === 1) {
+      kept += part;
+      return;
+    }
+    for (const grapheme of graphemesOf(part)) {
+      used += visibleLength(grapheme);
+      if (used > columns) {
+        return;
+      }
+      kept += grapheme;
+    }
+  });
+  return kept;
 }
 
 // src/statusline/barGrid.ts
@@ -137358,13 +137894,8 @@ function layoutBarGrid(groups, maxWidth, separator, baseBarCells) {
   return renderGrid(layoutFor(1), maxWidth, separator, baseBarCells);
 }
 
-// src/statusline/graphemes.ts
-var SEGMENTER = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-function graphemesOf(text4) {
-  return Array.from(SEGMENTER.segment(text4), (part) => part.segment);
-}
-
 // src/statusline/elements/header/account.ts
+init_graphemes();
 function tierSuffixOf(tier) {
   const match = /_(\d+x)$/i.exec(tier ?? "");
   return match === null ? void 0 : match[1];
@@ -137432,15 +137963,29 @@ function accountSegment({ summary, settings: settings2 }) {
 
 // src/statusline/sanitise.ts
 init_statusline();
-var BELL = "\\u0007";
-var ESCAPE_SEQUENCES = new RegExp([`${ESCAPE}\\[[0-?]*[ -/]*[@-~]`, `${ESCAPE}\\][^${BELL}${ESCAPE}]*(?:${BELL}|${ESCAPE}\\\\)`, `${ESCAPE}[@-Z\\\\-_]`].join("|"), "g");
-var CONTROL_AND_BIDI = /[\p{Cc}؜‎‏‪-‮⁦-⁩-]/gu;
+init_blank();
+init_graphemes();
+var ESCAPE_SEQUENCES = new RegExp(ESCAPE_SEQUENCE_PATTERN, "g");
+var CONTROL_AND_BIDI = /[\p{Cc}\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069\u206a-\u206f]/gu;
 function sanitiseDisplayText(text4) {
   return text4.replace(ESCAPE_SEQUENCES, "").replace(CONTROL_AND_BIDI, "");
 }
 function boundedDisplayText(text4) {
   return graphemesOf(sanitiseDisplayText(text4).trim()).slice(0, MAX_DISPLAY_TEXT_CHARS).join("").trim();
 }
+var TAG_SEQUENCE2 = "\\u{1F3F4}[\\u{E0020}-\\u{E007E}]+\\u{E007F}";
+var INVISIBLE_FORMAT = new RegExp(`(${TAG_SEQUENCE2})|(?![\\u200C\\u200D])\\p{Cf}`, "gu");
+var LINE_SEPARATORS = /[\u2028\u2029]/gu;
+var HANGUL_JAMO = "\\u1100-\\u115E\\u1161-\\u11FF\\uA960-\\uA97F\\uD7B0-\\uD7FF";
+var STANDALONE_HANGUL_FILLER = new RegExp(`(?<![${HANGUL_JAMO}])[\\u115F\\u1160](?![${HANGUL_JAMO}])`, "gu");
+function visibleDisplayText(text4) {
+  const cleaned = sanitiseDisplayText(text4).replace(LINE_SEPARATORS, "").replace(BLANK_CELLS, " ").replace(STANDALONE_HANGUL_FILLER, " ").replace(INVISIBLE_FORMAT, (_match, tagSequence) => tagSequence ?? "");
+  return graphemesOf(cleaned).map((grapheme) => {
+    const body = grapheme.replace(/^ /u, "");
+    const space = body === grapheme ? "" : " ";
+    return drawsNothing(body) ? space : grapheme;
+  }).join("").trim();
+}
 
 // src/statusline/elements/header/advisor.ts
 var MODEL_ID = /^(?:claude-)?(?:(\d{1,2})(?:-(\d{1,2}))?-)?(opus|sonnet|haiku)(?:-(\d{1,2})(?:-(\d{1,2}))?)?(?:-\d{8})?$/i;
@@ -137588,6 +138133,9 @@ function formatDuration(seconds) {
   if (seconds === void 0 || seconds <= 0) {
     return "available";
   }
+  if (seconds < SECONDS_PER_MINUTE2) {
+    return `${String(seconds)}s`;
+  }
   const days = Math.floor(seconds / SECONDS_PER_DAY);
   const hours = Math.floor(seconds % SECONDS_PER_DAY / (MINUTES_PER_HOUR4 * SECONDS_PER_MINUTE2));
   const minutes = Math.floor(seconds % (MINUTES_PER_HOUR4 * SECONDS_PER_MINUTE2) / SECONDS_PER_MINUTE2);
@@ -138146,56 +138694,11 @@ function gitFilesRow(context) {
 }
 
 // src/statusline/elements/rows/quota.ts
-function quotaRow(context) {
-  const { summary, nowMs, settings: settings2, palette } = context;
-  const style = barStyleOf(context, "usage");
-  const cells = [];
-  const drawWindow = (label2, fraction, resetsAt) => {
-    const clamped = Math.max(0, Math.min(1, fraction));
-    const color = statusColor(clamped, true, style);
-    cells.push(barCell(palette.paint("label", `${label2} `), ` ${withColor(color, `${(fraction * FULL_PERCENT3).toFixed(1)}%`)} (${formatDuration(secondsUntil(resetsAt, nowMs))})`, clamped, style));
-  };
-  if (summary.quotaFamilies.length > 0) {
-    for (const window of summary.quotaFamilies) {
-      drawWindow(window.measures, window.utilization, window.resetsAt);
-    }
-  } else {
-    if (summary.fiveHourUsed !== void 0) {
-      drawWindow(settings2.labels.fiveHour, summary.fiveHourUsed / FULL_PERCENT3, summary.fiveHourResetAt);
-    }
-    if (summary.sevenDayUsed !== void 0) {
-      drawWindow(settings2.labels.sevenDay, summary.sevenDayUsed / FULL_PERCENT3, summary.sevenDayResetAt);
-    }
-    if (summary.fiveHourUsed === void 0 && summary.sevenDayUsed === void 0) {
-      for (const window of summary.providerQuotaWindows) {
-        drawWindow(window.measures, window.utilization, window.resetsAt);
-      }
-    }
-  }
-  return { kind: "bars", cells };
-}
-
-// src/statusline/elements/registry.ts
-var HEADER_ROLES = {
-  model: "model",
-  provider: "model",
-  route: "label",
-  account: "label",
-  identity: "label",
-  headroom: "label",
-  project: "project",
-  vcs: "git",
-  effort: "model",
-  advisor: "label",
-  version: "label",
-  outputStyle: "label"
-};
-var ELEMENTS = {
-  header: { model: modelSegment, provider: providerSegment, route: routeSegment, account: accountSegment, identity: identitySegment, headroom: headroomSegment, project: projectSegment, vcs: vcsSegment, effort: effortSegment, advisor: advisorSegment, version: versionSegment, outputStyle: outputStyleSegment },
-  rows: { context: contextRow, quota: quotaRow, addedDirs: addedDirsRow, gitFiles: gitFilesRow }
-};
+init_statusline();
+init_pick();
 
 // src/statusline/headerLayout.ts
+var SEPARATOR2 = " | ";
 function headerUnits(parts, overflow) {
   const units = [];
   parts.forEach((part, index) => {
@@ -138235,7 +138738,7 @@ function justify(texts, maxWidth, separator) {
   });
   return parts.join("");
 }
-function layoutHeader(texts, maxWidth, separator) {
+function packLines(texts, maxWidth, separator) {
   const separatorLength = visibleLength(separator);
   const lines = [];
   let current = [];
@@ -138255,8 +138758,175 @@ function layoutHeader(texts, maxWidth, separator) {
   if (current.length > 0) {
     lines.push(current);
   }
-  return lines.map((line) => justify(line, maxWidth, separator)).join("\n");
+  return lines;
+}
+function layoutHeader(texts, maxWidth, separator) {
+  return packLines(texts, maxWidth, separator).map((line) => justify(line, maxWidth, separator)).join("\n");
+}
+
+// src/statusline/wallClock.ts
+var DAY_KEY_LOCALE = "en-CA";
+var FORMATTERS = /* @__PURE__ */ new Map();
+function formatterFor(locale, options) {
+  const key = JSON.stringify([locale, options]);
+  let formatter = FORMATTERS.get(key);
+  if (formatter === void 0) {
+    formatter = new Intl.DateTimeFormat(locale, options);
+    FORMATTERS.set(key, formatter);
+  }
+  return formatter;
+}
+function formatWallClock(atMs, nowMs, clock, settings2) {
+  const { locale, timeZone } = clock;
+  const time4 = formatterFor(locale, {
+    timeZone,
+    timeStyle: settings2.seconds ? "medium" : "short",
+    ...settings2.hourCycle === "auto" ? {} : { hourCycle: settings2.hourCycle }
+  }).format(atMs);
+  const dayKey = formatterFor(DAY_KEY_LOCALE, { timeZone, year: "numeric", month: "numeric", day: "numeric" });
+  if (dayKey.format(atMs) === dayKey.format(nowMs)) {
+    return time4;
+  }
+  return `${formatterFor(locale, { timeZone, month: "short", day: "numeric" }).format(atMs)} ${time4}`;
+}
+
+// src/statusline/resetTime.ts
+var AVAILABLE = formatDuration(void 0);
+function elapsedPercent(resetMs, periodMs, nowMs) {
+  if (!Number.isFinite(resetMs) || periodMs === void 0) {
+    return void 0;
+  }
+  const share = (nowMs - (resetMs - periodMs)) / periodMs * FULL_PERCENT3;
+  return Math.max(0, Math.min(FULL_PERCENT3, Math.round(share)));
+}
+function formatResetTime(window, nowMs, settings2, clock) {
+  const resetMs = window.resetsAt === void 0 ? Number.NaN : Date.parse(window.resetsAt);
+  const secondsLeft = secondsUntil(window.resetsAt, nowMs);
+  const pending = secondsLeft !== void 0 && secondsLeft > 0;
+  const relative = formatDuration(secondsLeft);
+  const absolute = pending ? `at ${formatWallClock(resetMs, nowMs, clock, settings2.clock)}` : AVAILABLE;
+  const elapsed = elapsedPercent(resetMs, window.periodMs, nowMs);
+  const elapsedText = elapsed === void 0 ? void 0 : `${String(elapsed)}% elapsed`;
+  switch (settings2.usage.timeFormat) {
+    case "relative":
+      return { text: relative, pending };
+    case "absolute":
+      return { text: absolute, pending };
+    case "both":
+      return { text: pending ? `${relative}, ${absolute}` : AVAILABLE, pending };
+    case "elapsed":
+      return { text: elapsedText ?? "", pending };
+    case "elapsedAndAbsolute":
+      return { text: [elapsedText, pending ? absolute : void 0].filter((part) => part !== void 0).join(", "), pending };
+    default:
+      return settings2.usage.timeFormat;
+  }
+}
+
+// src/statusline/elements/rows/quota.ts
+function safeLabel(label2) {
+  return truncateToColumns(visibleDisplayText(label2), MAX_STATUSLINE_LABEL_COLUMNS).trim();
+}
+function modelScopedWindows({ payload }) {
+  return (payload.rate_limits?.model_scoped ?? []).flatMap((window) => {
+    const label2 = safeLabel(window.display_name ?? "");
+    if (label2 === "" || window.utilization === void 0 || !Number.isFinite(window.utilization)) {
+      return [];
+    }
+    return [{ label: label2, fraction: window.utilization / FULL_PERCENT3, resetsAt: window.resets_at, periodMs: SEVEN_DAY_WINDOW_MS, weekly: false }];
+  });
+}
+function candidateWindows(context) {
+  const { summary, settings: settings2 } = context;
+  if (summary.quotaFamilies.length > 0) {
+    return summary.quotaFamilies.map((window) => ({ label: window.measures, fraction: window.utilization, resetsAt: window.resetsAt, periodMs: void 0, weekly: false }));
+  }
+  const windows = [];
+  if (summary.fiveHourUsed !== void 0) {
+    windows.push({ label: settings2.labels.fiveHour, fraction: summary.fiveHourUsed / FULL_PERCENT3, resetsAt: summary.fiveHourResetAt, periodMs: FIVE_HOUR_WINDOW_MS, weekly: false });
+  }
+  if (summary.sevenDayUsed !== void 0) {
+    windows.push({ label: settings2.labels.sevenDay, fraction: summary.sevenDayUsed / FULL_PERCENT3, resetsAt: summary.sevenDayResetAt, periodMs: SEVEN_DAY_WINDOW_MS, weekly: true });
+  }
+  if (summary.fiveHourUsed === void 0 && summary.sevenDayUsed === void 0) {
+    windows.push(...summary.providerQuotaWindows.map((window) => ({ label: window.measures, fraction: window.utilization, resetsAt: window.resetsAt, periodMs: window.periodMs, weekly: false })));
+  }
+  if (settings2.usage.modelScoped && summary.provider === void 0) {
+    windows.push(...modelScopedWindows(context));
+  }
+  return windows;
+}
+function visibleWindows(context) {
+  const { summary, settings: settings2 } = context;
+  const candidates = candidateWindows(context);
+  const mostUsed = Math.max(0, ...candidates.map((window) => window.fraction * FULL_PERCENT3));
+  if (mostUsed < settings2.usage.threshold) {
+    return [];
+  }
+  const hidesWeekly = summary.fiveHourUsed !== void 0 && summary.sevenDayUsed !== void 0 && summary.sevenDayUsed < settings2.usage.sevenDayThreshold;
+  return hidesWeekly ? candidates.filter((window) => !window.weekly) : candidates;
+}
+function figuresOf(window, context, style) {
+  const { settings: settings2, nowMs, ports } = context;
+  const clamped = Math.max(0, Math.min(1, window.fraction));
+  const used = window.fraction * FULL_PERCENT3;
+  const shown = settings2.usage.value === "remaining" ? Math.max(0, FULL_PERCENT3 - used) : used;
+  const { text: text4, pending } = formatResetTime(window, nowMs, settings2, ports.clock);
+  return { value: withColor(statusColor(clamped, true, style), `${shown.toFixed(1)}%`), reset: text4, pending };
+}
+function resetSuffix(reset, pending, context) {
+  if (reset === "") {
+    return "";
+  }
+  const { usage } = context.settings;
+  const elapsedForm = usage.timeFormat === "elapsed" || usage.timeFormat === "elapsedAndAbsolute";
+  if (!usage.resetLabel || !pending || elapsedForm) {
+    return `(${reset})`;
+  }
+  return `(${usage.timeFormat === "absolute" ? "resets" : "resets in"} ${reset})`;
 }
+function wrapped(windows, width) {
+  return packLines(windows, width, SEPARATOR2).map((line) => line.join(SEPARATOR2));
+}
+function quotaRow(context) {
+  const { palette, settings: settings2 } = context;
+  const style = barStyleOf(context, "usage");
+  const windows = visibleWindows(context);
+  const parts = windows.map((window) => {
+    const { value: value2, reset, pending } = figuresOf(window, context, style);
+    return { window, value: value2, reset, suffix: resetSuffix(reset, pending, context) };
+  });
+  if (settings2.usage.compact) {
+    const lines = parts.map(({ window, value: value2, reset }) => `${palette.paint("label", `${window.label}:`)} ${value2}${reset === "" ? "" : ` ${palette.paint("label", `(${reset})`)}`}`);
+    return { kind: "text", lines: wrapped(lines, context.width) };
+  }
+  if (!settings2.usage.bar) {
+    const lines = parts.map(({ window, value: value2, suffix }) => `${palette.paint("label", `${window.label} `)}${value2}${suffix === "" ? "" : ` ${suffix}`}`);
+    return { kind: "text", lines: wrapped(lines, context.width) };
+  }
+  const cells = parts.map(({ window, value: value2, suffix }) => barCell(palette.paint("label", `${window.label} `), ` ${value2}${suffix === "" ? "" : ` ${suffix}`}`, Math.max(0, Math.min(1, window.fraction)), style));
+  return { kind: "bars", cells };
+}
+
+// src/statusline/elements/registry.ts
+var HEADER_ROLES = {
+  model: "model",
+  provider: "model",
+  route: "label",
+  account: "label",
+  identity: "label",
+  headroom: "label",
+  project: "project",
+  vcs: "git",
+  effort: "model",
+  advisor: "label",
+  version: "label",
+  outputStyle: "label"
+};
+var ELEMENTS = {
+  header: { model: modelSegment, provider: providerSegment, route: routeSegment, account: accountSegment, identity: identitySegment, headroom: headroomSegment, project: projectSegment, vcs: vcsSegment, effort: effortSegment, advisor: advisorSegment, version: versionSegment, outputStyle: outputStyleSegment },
+  rows: { context: contextRow, quota: quotaRow, addedDirs: addedDirsRow, gitFiles: gitFilesRow }
+};
 
 // src/statusline/identityTranscript.ts
 init_zod();
@@ -138350,7 +139020,6 @@ function readTranscriptIdentity(ports, transcriptPath) {
 
 // src/statusline/render.ts
 var RESERVED_COLUMNS = 4;
-var SEPARATOR2 = " | ";
 function once2(read) {
   let kept;
   return () => {
@@ -138360,12 +139029,14 @@ function once2(read) {
 }
 function renderStatuslineBlock(input2) {
   const { terminalWidth, settings: settings2 = STATUSLINE_DEFAULTS, elements = ELEMENTS } = input2;
+  const width = Math.max(TWENTY, terminalWidth - RESERVED_COLUMNS);
   const context = {
     summary: input2.summary,
     view: input2.view,
     payload: input2.payload,
     nowMs: input2.nowMs,
     terminalWidth,
+    width,
     settings: settings2,
     palette: createPalette(settings2.colours, colourEnabled(input2.ports.env)),
     ports: input2.ports,
@@ -138376,7 +139047,6 @@ function renderStatuslineBlock(input2) {
     return text4 === void 0 ? [] : { name, text: context.palette.paint(HEADER_ROLES[name], text4) };
   });
   const header = headerUnits(parts, settings2.git.branchOverflow);
-  const width = Math.max(TWENTY, terminalWidth - RESERVED_COLUMNS);
   const lines = [];
   if (header.length > 0) {
     lines.push(layoutHeader(header, width, SEPARATOR2));
@@ -141043,13 +141713,13 @@ function timeRegex(args) {
   return new RegExp(`^${timeRegexSource(args)}$`);
 }
 function datetimeRegex(args) {
-  let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
+  let regex2 = `${dateRegexSource}T${timeRegexSource(args)}`;
   const opts = [];
   opts.push(args.local ? `Z?` : `Z`);
   if (args.offset)
     opts.push(`([+-]\\d{2}:?\\d{2})`);
-  regex = `${regex}(${opts.join("|")})`;
-  return new RegExp(`^${regex}$`);
+  regex2 = `${regex2}(${opts.join("|")})`;
+  return new RegExp(`^${regex2}$`);
 }
 function isValidIP(ip2, version2) {
   if ((version2 === "v4" || !version2) && ipv4Regex.test(ip2)) {
@@ -141295,8 +141965,8 @@ var ZodString2 = class _ZodString2 extends ZodType2 {
           status.dirty();
         }
       } else if (check2.kind === "datetime") {
-        const regex = datetimeRegex(check2);
-        if (!regex.test(input2.data)) {
+        const regex2 = datetimeRegex(check2);
+        if (!regex2.test(input2.data)) {
           ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode2.invalid_string,
@@ -141306,8 +141976,8 @@ var ZodString2 = class _ZodString2 extends ZodType2 {
           status.dirty();
         }
       } else if (check2.kind === "date") {
-        const regex = dateRegex;
-        if (!regex.test(input2.data)) {
+        const regex2 = dateRegex;
+        if (!regex2.test(input2.data)) {
           ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode2.invalid_string,
@@ -141317,8 +141987,8 @@ var ZodString2 = class _ZodString2 extends ZodType2 {
           status.dirty();
         }
       } else if (check2.kind === "time") {
-        const regex = timeRegex(check2);
-        if (!regex.test(input2.data)) {
+        const regex2 = timeRegex(check2);
+        if (!regex2.test(input2.data)) {
           ctx = this._getOrReturnCtx(input2, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode2.invalid_string,
@@ -141393,8 +142063,8 @@ var ZodString2 = class _ZodString2 extends ZodType2 {
     }
     return { status: status.value, value: input2.data };
   }
-  _regex(regex, validation, message) {
-    return this.refinement((data) => regex.test(data), {
+  _regex(regex2, validation, message) {
+    return this.refinement((data) => regex2.test(data), {
       validation,
       code: ZodIssueCode2.invalid_string,
       ...errorUtil.errToObj(message)
@@ -141486,10 +142156,10 @@ var ZodString2 = class _ZodString2 extends ZodType2 {
   duration(message) {
     return this._addCheck({ kind: "duration", ...errorUtil.errToObj(message) });
   }
-  regex(regex, message) {
+  regex(regex2, message) {
     return this._addCheck({
       kind: "regex",
-      regex,
+      regex: regex2,
       ...errorUtil.errToObj(message)
     });
   }
@@ -144863,7 +145533,7 @@ function addFormat(schema, value2, message, refs) {
     setResponseValueAndErrors(schema, "format", value2, message, refs);
   }
 }
-function addPattern2(schema, regex, message, refs) {
+function addPattern2(schema, regex2, message, refs) {
   if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
     if (!schema.allOf) {
       schema.allOf = [];
@@ -144884,24 +145554,24 @@ function addPattern2(schema, regex, message, refs) {
       }
     }
     schema.allOf.push({
-      pattern: stringifyRegExpWithFlags(regex, refs),
+      pattern: stringifyRegExpWithFlags(regex2, refs),
       ...message && refs.errorMessages && { errorMessage: { pattern: message } }
     });
   } else {
-    setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
+    setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex2, refs), message, refs);
   }
 }
-function stringifyRegExpWithFlags(regex, refs) {
-  if (!refs.applyRegexFlags || !regex.flags) {
-    return regex.source;
+function stringifyRegExpWithFlags(regex2, refs) {
+  if (!refs.applyRegexFlags || !regex2.flags) {
+    return regex2.source;
   }
   const flags = {
-    i: regex.flags.includes("i"),
-    m: regex.flags.includes("m"),
-    s: regex.flags.includes("s")
+    i: regex2.flags.includes("i"),
+    m: regex2.flags.includes("m"),
+    s: regex2.flags.includes("s")
     // `.` matches newlines
   };
-  const source = flags.i ? regex.source.toLowerCase() : regex.source;
+  const source = flags.i ? regex2.source.toLowerCase() : regex2.source;
   let pattern = "";
   let isEscaped = false;
   let inCharGroup = false;
@@ -144962,7 +145632,7 @@ function stringifyRegExpWithFlags(regex, refs) {
     new RegExp(pattern);
   } catch {
     console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
-    return regex.source;
+    return regex2.source;
   }
   return pattern;
 }