@vectorize-io/hindsight-coding-agents 0.5.0 → 0.5.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (47) hide show
  1. package/README.md +44 -3
  2. package/dist/antigravity-hook.js +142 -9
  3. package/dist/antigravity-statusline.js +42 -4
  4. package/dist/antigravity-stop-hook.js +222 -59
  5. package/dist/claude-hook.js +142 -9
  6. package/dist/claude-sessionstart-hook.js +145 -11
  7. package/dist/claude-stop-hook.js +222 -59
  8. package/dist/cline.js +149 -61
  9. package/dist/codex-hook.js +142 -9
  10. package/dist/codex-sessionstart-hook.js +145 -11
  11. package/dist/codex-stop-hook.js +222 -59
  12. package/dist/copilot-hook.js +142 -9
  13. package/dist/copilot-sessionstart-hook.js +145 -11
  14. package/dist/copilot-stop-hook.js +222 -59
  15. package/dist/cursor-hook.js +142 -9
  16. package/dist/cursor-sessionstart-hook.js +145 -11
  17. package/dist/cursor-stop-hook.js +222 -59
  18. package/dist/daemon-start.js +36 -2
  19. package/dist/dcode-hook.js +142 -9
  20. package/dist/dcode-sessionstart-hook.js +145 -11
  21. package/dist/dcode-stop-hook.js +222 -59
  22. package/dist/deepen.js +97 -14
  23. package/dist/devin-hook.js +142 -9
  24. package/dist/devin-sessionstart-hook.js +145 -11
  25. package/dist/devin-stop-hook.js +222 -59
  26. package/dist/droid-hook.js +2710 -0
  27. package/dist/droid-sessionstart-hook.js +3328 -0
  28. package/dist/droid-stop-hook.js +2970 -0
  29. package/dist/dsh.js +154 -62
  30. package/dist/grok-hook.js +142 -9
  31. package/dist/grok-sessionstart-hook.js +145 -11
  32. package/dist/grok-stop-hook.js +222 -59
  33. package/dist/hindsight-seed.js +42 -4
  34. package/dist/index.js +149 -61
  35. package/dist/installer.js +155 -13
  36. package/dist/kilo.js +149 -61
  37. package/dist/mcp-server.js +474 -133
  38. package/dist/opencode2.js +149 -61
  39. package/dist/pi.js +149 -61
  40. package/dist/prime-agent.js +149 -61
  41. package/dist/qwen-hook.js +142 -9
  42. package/dist/qwen-sessionstart-hook.js +145 -11
  43. package/dist/qwen-stop-hook.js +222 -59
  44. package/dist/status.js +65 -7
  45. package/package.json +6 -3
  46. package/plugin.json +1 -1
  47. package/skill/SKILL.md +26 -2
@@ -3109,9 +3109,28 @@ var require_utils = __commonJS({
3109
3109
  "use strict";
3110
3110
  var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
3111
3111
  var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
3112
+ var isPort = RegExp.prototype.test.bind(/^\d*$/u);
3112
3113
  var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
3113
3114
  var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
3114
- var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
3115
+ var isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
3116
+ var isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
3117
+ var isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
3118
+ var BYTE_HEX = new Array(256);
3119
+ {
3120
+ const HEX_DIGITS = "0123456789ABCDEF";
3121
+ for (let i = 0; i < 256; i++) {
3122
+ BYTE_HEX[i] = "%" + HEX_DIGITS[i >> 4] + HEX_DIGITS[i & 15];
3123
+ }
3124
+ }
3125
+ function percentEncodeNonAscii(cp) {
3126
+ if (cp < 2048) {
3127
+ return BYTE_HEX[192 | cp >> 6] + BYTE_HEX[128 | cp & 63];
3128
+ }
3129
+ if (cp < 65536) {
3130
+ return BYTE_HEX[224 | cp >> 12] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
3131
+ }
3132
+ return BYTE_HEX[240 | cp >> 18] + BYTE_HEX[128 | cp >> 12 & 63] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
3133
+ }
3115
3134
  function stringArrayToHexStripped(input) {
3116
3135
  let acc = "";
3117
3136
  let code = 0;
@@ -3136,91 +3155,105 @@ var require_utils = __commonJS({
3136
3155
  }
3137
3156
  return acc;
3138
3157
  }
3158
+ var isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
3159
+ var isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
3160
+ var isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
3139
3161
  var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
3140
- function consumeIsZone(buffer) {
3141
- buffer.length = 0;
3142
- return true;
3143
- }
3144
- function consumeHextets(buffer, address, output) {
3145
- if (buffer.length) {
3146
- const hex3 = stringArrayToHexStripped(buffer);
3147
- if (hex3 !== "") {
3148
- address.push(hex3);
3149
- } else {
3150
- output.error = true;
3151
- return false;
3162
+ function isZoneIdentifier(zone) {
3163
+ if (zone.length === 0) return false;
3164
+ for (let i = 0; i < zone.length; i++) {
3165
+ if (isZoneCharacter(zone[i])) continue;
3166
+ if (zone[i] === "%" && i + 2 < zone.length && isHexPair(zone.slice(i + 1, i + 3))) {
3167
+ i += 2;
3168
+ continue;
3152
3169
  }
3153
- buffer.length = 0;
3170
+ return false;
3154
3171
  }
3155
3172
  return true;
3156
3173
  }
3157
- function getIPV6(input) {
3158
- let tokenCount = 0;
3159
- const output = { error: false, address: "", zone: "" };
3160
- const address = [];
3161
- const buffer = [];
3162
- let endipv6Encountered = false;
3163
- let endIpv6 = false;
3164
- let consume = consumeHextets;
3165
- for (let i = 0; i < input.length; i++) {
3166
- const cursor = input[i];
3167
- if (cursor === "[" || cursor === "]") {
3168
- continue;
3169
- }
3170
- if (cursor === ":") {
3171
- if (endipv6Encountered === true) {
3172
- endIpv6 = true;
3173
- }
3174
- if (!consume(buffer, address, output)) {
3175
- break;
3176
- }
3177
- if (++tokenCount > 7) {
3178
- output.error = true;
3179
- break;
3180
- }
3181
- if (i > 0 && input[i - 1] === ":") {
3182
- endipv6Encountered = true;
3183
- }
3184
- address.push(":");
3185
- continue;
3186
- } else if (cursor === "%") {
3187
- if (!consume(buffer, address, output)) {
3188
- break;
3174
+ function compressIPv6ZeroRun(hextets) {
3175
+ let bestStart = -1;
3176
+ let bestLength = 0;
3177
+ let runStart = -1;
3178
+ let runLength = 0;
3179
+ for (let i = 0; i < hextets.length; i++) {
3180
+ if (hextets[i] === "0") {
3181
+ if (runStart === -1) runStart = i;
3182
+ runLength++;
3183
+ if (runLength > bestLength) {
3184
+ bestLength = runLength;
3185
+ bestStart = runStart;
3189
3186
  }
3190
- consume = consumeIsZone;
3191
3187
  } else {
3192
- buffer.push(cursor);
3188
+ runStart = -1;
3189
+ runLength = 0;
3190
+ }
3191
+ }
3192
+ if (bestLength < 2) return hextets.join(":");
3193
+ const head = hextets.slice(0, bestStart).join(":");
3194
+ const tail = hextets.slice(bestStart + bestLength).join(":");
3195
+ return head + "::" + tail;
3196
+ }
3197
+ function normalizeIPv6Address(input) {
3198
+ const compression = input.indexOf("::");
3199
+ if (compression !== -1 && input.indexOf("::", compression + 1) !== -1) return void 0;
3200
+ const left = compression === -1 ? input.split(":") : input.slice(0, compression).split(":");
3201
+ const right = compression === -1 ? [] : input.slice(compression + 2).split(":");
3202
+ if (compression !== -1) {
3203
+ if (left.length === 1 && left[0] === "") left.length = 0;
3204
+ if (right.length === 1 && right[0] === "") right.length = 0;
3205
+ }
3206
+ const parts = left.concat(right);
3207
+ let hextetCount = 0;
3208
+ for (let i = 0; i < parts.length; i++) {
3209
+ const part = parts[i];
3210
+ if (part === "") return void 0;
3211
+ if (part.indexOf(".") !== -1) {
3212
+ if (i !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part)) return void 0;
3213
+ hextetCount += 2;
3193
3214
  continue;
3194
3215
  }
3216
+ if (!isHextet(part)) return void 0;
3217
+ parts[i] = parseInt(part, 16).toString(16);
3218
+ hextetCount++;
3195
3219
  }
3196
- if (buffer.length) {
3197
- if (consume === consumeIsZone) {
3198
- output.zone = buffer.join("");
3199
- } else if (endIpv6) {
3200
- address.push(buffer.join(""));
3201
- } else {
3202
- address.push(stringArrayToHexStripped(buffer));
3203
- }
3220
+ if (compression === -1) {
3221
+ if (hextetCount !== 8) return void 0;
3222
+ return compressIPv6ZeroRun(parts);
3204
3223
  }
3205
- output.address = address.join("");
3206
- return output;
3224
+ if (hextetCount >= 8) return void 0;
3225
+ const expanded = parts.slice(0, left.length);
3226
+ for (let i = hextetCount; i < 8; i++) expanded.push("0");
3227
+ for (let i = left.length; i < parts.length; i++) expanded.push(parts[i]);
3228
+ return compressIPv6ZeroRun(expanded);
3207
3229
  }
3208
3230
  function normalizeIPv6(host) {
3209
- if (findToken(host, ":") < 2) {
3210
- return { host, isIPV6: false };
3211
- }
3212
- const ipv63 = getIPV6(host);
3213
- if (!ipv63.error) {
3214
- let newHost = ipv63.address;
3215
- let escapedHost = ipv63.address;
3216
- if (ipv63.zone) {
3217
- newHost += "%" + ipv63.zone;
3218
- escapedHost += "%25" + ipv63.zone;
3219
- }
3220
- return { host: newHost, isIPV6: true, escapedHost };
3221
- } else {
3222
- return { host, isIPV6: false };
3223
- }
3231
+ const bracketed = host[0] === "[" && host[host.length - 1] === "]";
3232
+ const hasBracket = host[0] === "[" || host[host.length - 1] === "]";
3233
+ if (hasBracket && !bracketed) return { host, isIPV6: false, error: true };
3234
+ let input = bracketed ? host.slice(1, -1) : host;
3235
+ if (bracketed && isIPvFuture(input)) {
3236
+ input = input.toLowerCase();
3237
+ return { host: `[${input}]`, escapedHost: input, isIPV6: false, isIPVFuture: true };
3238
+ }
3239
+ if (findToken(input, ":") < 2) {
3240
+ return { host, isIPV6: false, error: bracketed };
3241
+ }
3242
+ let zoneIdentifier = "";
3243
+ const zoneSeparator = input.indexOf("%");
3244
+ if (zoneSeparator !== -1) {
3245
+ const separatorLength = input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
3246
+ zoneIdentifier = input.slice(zoneSeparator + separatorLength);
3247
+ if (!isZoneIdentifier(zoneIdentifier)) return { host, isIPV6: false, error: true };
3248
+ input = input.slice(0, zoneSeparator);
3249
+ }
3250
+ const address = normalizeIPv6Address(input);
3251
+ if (address === void 0) return { host, isIPV6: false, error: true };
3252
+ return {
3253
+ host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
3254
+ escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
3255
+ isIPV6: true
3256
+ };
3224
3257
  }
3225
3258
  function findToken(str, token) {
3226
3259
  let ind = 0;
@@ -3339,7 +3372,8 @@ var require_utils = __commonJS({
3339
3372
  function normalizePathEncoding(input) {
3340
3373
  let output = "";
3341
3374
  for (let i = 0; i < input.length; i++) {
3342
- if (input[i] === "%" && i + 2 < input.length) {
3375
+ const ch = input[i];
3376
+ if (ch === "%" && i + 2 < input.length) {
3343
3377
  const hex3 = input.slice(i + 1, i + 3);
3344
3378
  if (isHexPair(hex3)) {
3345
3379
  const normalizedHex = hex3.toUpperCase();
@@ -3353,10 +3387,152 @@ var require_utils = __commonJS({
3353
3387
  continue;
3354
3388
  }
3355
3389
  }
3356
- if (isPathCharacter(input[i])) {
3357
- output += input[i];
3390
+ if (isPathCharacter(ch)) {
3391
+ output += ch;
3392
+ } else {
3393
+ const code = input.charCodeAt(i);
3394
+ if (code < 128) {
3395
+ output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
3396
+ } else if (code < 55296 || code > 57343) {
3397
+ output += percentEncodeNonAscii(code);
3398
+ } else if (code <= 56319 && i + 1 < input.length) {
3399
+ const low = input.charCodeAt(i + 1);
3400
+ if (low >= 56320 && low <= 57343) {
3401
+ output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
3402
+ i++;
3403
+ } else {
3404
+ output += percentEncodeNonAscii(65533);
3405
+ }
3406
+ } else {
3407
+ output += percentEncodeNonAscii(65533);
3408
+ }
3409
+ }
3410
+ }
3411
+ return output;
3412
+ }
3413
+ function serializePathEncoding(input, pathNoScheme = false) {
3414
+ let output = "";
3415
+ let firstSegment = pathNoScheme && input[0] !== "/";
3416
+ for (let i = 0; i < input.length; i++) {
3417
+ const ch = input[i];
3418
+ if (ch === "%" && i + 2 < input.length) {
3419
+ const hex3 = input.slice(i + 1, i + 3);
3420
+ if (isHexPair(hex3)) {
3421
+ output += "%" + hex3.toUpperCase();
3422
+ i += 2;
3423
+ continue;
3424
+ }
3425
+ }
3426
+ if (ch === "/") {
3427
+ firstSegment = false;
3428
+ }
3429
+ if (isPathCharacter(ch) && (ch !== ":" || !firstSegment)) {
3430
+ output += ch;
3431
+ } else {
3432
+ const code = input.charCodeAt(i);
3433
+ if (code < 128) {
3434
+ output += BYTE_HEX[code];
3435
+ } else if (code < 55296 || code > 57343) {
3436
+ output += percentEncodeNonAscii(code);
3437
+ } else if (code <= 56319 && i + 1 < input.length) {
3438
+ const low = input.charCodeAt(i + 1);
3439
+ if (low >= 56320 && low <= 57343) {
3440
+ output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
3441
+ i++;
3442
+ } else {
3443
+ output += percentEncodeNonAscii(65533);
3444
+ }
3445
+ } else {
3446
+ output += percentEncodeNonAscii(65533);
3447
+ }
3448
+ }
3449
+ }
3450
+ return output;
3451
+ }
3452
+ function encodeComponent(input, isAllowed) {
3453
+ let output = "";
3454
+ for (let i = 0; i < input.length; i++) {
3455
+ const ch = input[i];
3456
+ if (ch === "%" && i + 2 < input.length) {
3457
+ const hex3 = input.slice(i + 1, i + 3);
3458
+ if (isHexPair(hex3)) {
3459
+ output += "%" + hex3.toUpperCase();
3460
+ i += 2;
3461
+ continue;
3462
+ }
3463
+ }
3464
+ if (isAllowed(ch)) {
3465
+ output += ch;
3466
+ } else {
3467
+ const code = input.charCodeAt(i);
3468
+ if (code < 128) {
3469
+ output += BYTE_HEX[code];
3470
+ } else if (code < 55296 || code > 57343) {
3471
+ output += percentEncodeNonAscii(code);
3472
+ } else if (code <= 56319 && i + 1 < input.length) {
3473
+ const low = input.charCodeAt(i + 1);
3474
+ if (low >= 56320 && low <= 57343) {
3475
+ output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
3476
+ i++;
3477
+ } else {
3478
+ output += percentEncodeNonAscii(65533);
3479
+ }
3480
+ } else {
3481
+ output += percentEncodeNonAscii(65533);
3482
+ }
3483
+ }
3484
+ }
3485
+ return output;
3486
+ }
3487
+ function encodeUserinfo(input) {
3488
+ return encodeComponent(input, isUserinfoCharacter);
3489
+ }
3490
+ function encodeQuery(input) {
3491
+ return encodeComponent(input, isQueryFragmentCharacter);
3492
+ }
3493
+ function encodeFragment(input) {
3494
+ return encodeComponent(input, isQueryFragmentCharacter);
3495
+ }
3496
+ function isEscapeSafe(cp) {
3497
+ return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 42 || cp === 43 || cp === 45 || cp === 46 || cp === 47 || cp === 64 || cp === 95;
3498
+ }
3499
+ function normalizeQueryFragmentEncoding(input) {
3500
+ let output = "";
3501
+ for (let i = 0; i < input.length; i++) {
3502
+ const ch = input[i];
3503
+ if (ch === "%" && i + 2 < input.length) {
3504
+ const hex3 = input.slice(i + 1, i + 3);
3505
+ if (isHexPair(hex3)) {
3506
+ const normalizedHex = hex3.toUpperCase();
3507
+ const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
3508
+ if (isUnreserved(decoded)) {
3509
+ output += decoded;
3510
+ } else {
3511
+ output += "%" + normalizedHex;
3512
+ }
3513
+ i += 2;
3514
+ continue;
3515
+ }
3516
+ }
3517
+ if (isQueryFragmentCharacter(ch)) {
3518
+ output += ch;
3358
3519
  } else {
3359
- output += escape(input[i]);
3520
+ const code = input.charCodeAt(i);
3521
+ if (code < 128) {
3522
+ output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
3523
+ } else if (code < 55296 || code > 57343) {
3524
+ output += percentEncodeNonAscii(code);
3525
+ } else if (code <= 56319 && i + 1 < input.length) {
3526
+ const low = input.charCodeAt(i + 1);
3527
+ if (low >= 56320 && low <= 57343) {
3528
+ output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
3529
+ i++;
3530
+ } else {
3531
+ output += percentEncodeNonAscii(65533);
3532
+ }
3533
+ } else {
3534
+ output += percentEncodeNonAscii(65533);
3535
+ }
3360
3536
  }
3361
3537
  }
3362
3538
  return output;
@@ -3379,14 +3555,18 @@ var require_utils = __commonJS({
3379
3555
  function recomposeAuthority(component) {
3380
3556
  const uriTokens = [];
3381
3557
  if (component.userinfo !== void 0) {
3382
- uriTokens.push(component.userinfo);
3558
+ uriTokens.push(encodeUserinfo(component.userinfo));
3383
3559
  uriTokens.push("@");
3384
3560
  }
3385
3561
  if (component.host !== void 0) {
3386
- let host = unescape(component.host);
3562
+ let host = component.host;
3387
3563
  if (!isIPv4(host)) {
3388
- const ipV6res = normalizeIPv6(host);
3389
- if (ipV6res.isIPV6 === true) {
3564
+ let ipV6res = normalizeIPv6(host);
3565
+ if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
3566
+ host = normalizePercentEncoding(host, true);
3567
+ ipV6res = normalizeIPv6(host);
3568
+ }
3569
+ if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) {
3390
3570
  host = `[${ipV6res.escapedHost}]`;
3391
3571
  } else {
3392
3572
  host = reescapeHostDelimiters(host, false);
@@ -3395,8 +3575,12 @@ var require_utils = __commonJS({
3395
3575
  uriTokens.push(host);
3396
3576
  }
3397
3577
  if (typeof component.port === "number" || typeof component.port === "string") {
3578
+ const port = String(component.port);
3579
+ if (!isPort(port)) {
3580
+ throw new TypeError("URI port is malformed.");
3581
+ }
3398
3582
  uriTokens.push(":");
3399
- uriTokens.push(String(component.port));
3583
+ uriTokens.push(port);
3400
3584
  }
3401
3585
  return uriTokens.length ? uriTokens.join("") : void 0;
3402
3586
  }
@@ -3406,6 +3590,11 @@ var require_utils = __commonJS({
3406
3590
  reescapeHostDelimiters,
3407
3591
  normalizePercentEncoding,
3408
3592
  normalizePathEncoding,
3593
+ serializePathEncoding,
3594
+ normalizeQueryFragmentEncoding,
3595
+ encodeUserinfo,
3596
+ encodeQuery,
3597
+ encodeFragment,
3409
3598
  escapePreservingEscapes,
3410
3599
  removeDotSegments,
3411
3600
  isIPv4,
@@ -3421,7 +3610,7 @@ var require_schemes = __commonJS({
3421
3610
  "node_modules/fast-uri/lib/schemes.js"(exports, module) {
3422
3611
  "use strict";
3423
3612
  var { isUUID } = require_utils();
3424
- var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
3613
+ var URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
3425
3614
  var supportedSchemeNames = (
3426
3615
  /** @type {const} */
3427
3616
  [
@@ -3482,9 +3671,10 @@ var require_schemes = __commonJS({
3482
3671
  wsComponent.secure = void 0;
3483
3672
  }
3484
3673
  if (wsComponent.resourceName) {
3485
- const [path, query] = wsComponent.resourceName.split("?");
3674
+ const queryIndex = wsComponent.resourceName.indexOf("?");
3675
+ const path = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
3486
3676
  wsComponent.path = path && path !== "/" ? path : void 0;
3487
- wsComponent.query = query;
3677
+ wsComponent.query = queryIndex === -1 ? void 0 : wsComponent.resourceName.slice(queryIndex + 1);
3488
3678
  wsComponent.resourceName = void 0;
3489
3679
  }
3490
3680
  wsComponent.fragment = void 0;
@@ -3496,7 +3686,7 @@ var require_schemes = __commonJS({
3496
3686
  return urnComponent;
3497
3687
  }
3498
3688
  const matches = urnComponent.path.match(URN_REG);
3499
- if (matches) {
3689
+ if (matches && matches[0] === urnComponent.path) {
3500
3690
  const scheme = options.scheme || urnComponent.scheme || "urn";
3501
3691
  urnComponent.nid = matches[1].toLowerCase();
3502
3692
  urnComponent.nss = matches[2];
@@ -3630,8 +3820,17 @@ var require_schemes = __commonJS({
3630
3820
  var require_fast_uri = __commonJS({
3631
3821
  "node_modules/fast-uri/index.js"(exports, module) {
3632
3822
  "use strict";
3633
- var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
3823
+ var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
3634
3824
  var { SCHEMES, getSchemeHandler } = require_schemes();
3825
+ var VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
3826
+ var MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
3827
+ function decodeValidScheme(scheme) {
3828
+ const decodedScheme = unescape(String(scheme));
3829
+ if (!VALID_SCHEME.test(decodedScheme)) {
3830
+ throw new TypeError(MALFORMED_SCHEME_ERROR);
3831
+ }
3832
+ return decodedScheme;
3833
+ }
3635
3834
  function normalize2(uri, options) {
3636
3835
  if (typeof uri === "string") {
3637
3836
  uri = /** @type {T} */
@@ -3644,12 +3843,34 @@ var require_fast_uri = __commonJS({
3644
3843
  }
3645
3844
  function resolve3(baseURI, relativeURI, options) {
3646
3845
  const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
3647
- const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
3648
- const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
3649
- if (baseMalformed || relativeMalformed) {
3846
+ const {
3847
+ parsed: baseParsed,
3848
+ malformedAuthorityOrPort: baseMalformed,
3849
+ malformedPercentEncoding: baseMalformedPercentEncoding,
3850
+ malformedSchemeSpecific: baseMalformedSchemeSpecific,
3851
+ malformedHost: baseMalformedHost,
3852
+ malformedScheme: baseMalformedScheme
3853
+ } = parseWithStatus(baseURI, schemelessOptions);
3854
+ const {
3855
+ parsed: relativeParsed,
3856
+ malformedAuthorityOrPort: relativeMalformed,
3857
+ malformedPercentEncoding: relativeMalformedPercentEncoding,
3858
+ malformedSchemeSpecific: relativeMalformedSchemeSpecific,
3859
+ malformedHost: relativeMalformedHost,
3860
+ malformedScheme: relativeMalformedScheme
3861
+ } = parseWithStatus(relativeURI, schemelessOptions);
3862
+ if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) {
3650
3863
  throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
3651
3864
  }
3652
3865
  const resolved2 = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
3866
+ const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved2.scheme);
3867
+ const resolvedHost = resolved2.host;
3868
+ const resolvedHostIsIP = resolvedHost !== void 0 && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
3869
+ canonicalizeHost(resolved2, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
3870
+ const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !new RegExp("\\P{ASCII}", "u").test(resolvedHost);
3871
+ if (resolved2.error && !encodedASCIIHost) {
3872
+ throw new Error(resolved2.error);
3873
+ }
3653
3874
  schemelessOptions.skipEscape = true;
3654
3875
  return serialize(resolved2, schemelessOptions);
3655
3876
  }
@@ -3709,7 +3930,7 @@ var require_fast_uri = __commonJS({
3709
3930
  function equal(uriA, uriB, options) {
3710
3931
  const normalizedA = normalizeComparableURI(uriA, options);
3711
3932
  const normalizedB = normalizeComparableURI(uriB, options);
3712
- return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
3933
+ return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA === normalizedB;
3713
3934
  }
3714
3935
  function serialize(cmpts, opts) {
3715
3936
  const component = {
@@ -3730,19 +3951,22 @@ var require_fast_uri = __commonJS({
3730
3951
  };
3731
3952
  const options = Object.assign({}, opts);
3732
3953
  const uriTokens = [];
3954
+ if (component.scheme) {
3955
+ component.scheme = decodeValidScheme(component.scheme);
3956
+ }
3733
3957
  const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
3734
3958
  if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
3959
+ const hasAuthority = component.userinfo !== void 0 || component.host !== void 0 || component.port !== void 0;
3960
+ const pathNoScheme = !options.skipEscape && component.scheme === void 0 && !hasAuthority;
3735
3961
  if (component.path !== void 0) {
3736
3962
  if (!options.skipEscape) {
3737
- component.path = escapePreservingEscapes(component.path);
3738
- if (component.scheme !== void 0) {
3739
- component.path = component.path.split("%3A").join(":");
3740
- }
3963
+ component.path = serializePathEncoding(component.path, pathNoScheme);
3741
3964
  } else {
3742
3965
  component.path = normalizePercentEncoding(component.path);
3743
3966
  }
3744
3967
  }
3745
3968
  if (options.reference !== "suffix" && component.scheme) {
3969
+ component.scheme = decodeValidScheme(component.scheme);
3746
3970
  uriTokens.push(component.scheme, ":");
3747
3971
  }
3748
3972
  const authority = recomposeAuthority(component);
@@ -3760,16 +3984,19 @@ var require_fast_uri = __commonJS({
3760
3984
  if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
3761
3985
  s = removeDotSegments(s);
3762
3986
  }
3987
+ if (pathNoScheme) {
3988
+ s = serializePathEncoding(s, true);
3989
+ }
3763
3990
  if (authority === void 0 && s[0] === "/" && s[1] === "/") {
3764
3991
  s = "/%2F" + s.slice(2);
3765
3992
  }
3766
3993
  uriTokens.push(s);
3767
3994
  }
3768
3995
  if (component.query !== void 0) {
3769
- uriTokens.push("?", component.query);
3996
+ uriTokens.push("?", encodeQuery(component.query));
3770
3997
  }
3771
3998
  if (component.fragment !== void 0) {
3772
- uriTokens.push("#", component.fragment);
3999
+ uriTokens.push("#", encodeFragment(component.fragment));
3773
4000
  }
3774
4001
  return uriTokens.join("");
3775
4002
  }
@@ -3785,6 +4012,35 @@ var require_fast_uri = __commonJS({
3785
4012
  }
3786
4013
  return void 0;
3787
4014
  }
4015
+ function hasMalformedPercentEncoding(component) {
4016
+ if (component === void 0) return false;
4017
+ let percent = component.indexOf("%");
4018
+ while (percent !== -1) {
4019
+ if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) {
4020
+ return true;
4021
+ }
4022
+ percent = component.indexOf("%", percent + 3);
4023
+ }
4024
+ return false;
4025
+ }
4026
+ function isIPLiteral(host) {
4027
+ return host[0] === "[" && host[host.length - 1] === "]";
4028
+ }
4029
+ function hasMalformedComponentPercentEncoding(matches) {
4030
+ const host = matches[4];
4031
+ return hasMalformedPercentEncoding(matches[3]) || host !== void 0 && !isIPLiteral(host) && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
4032
+ }
4033
+ function canonicalizeHost(parsed, options, schemeHandler, isIP) {
4034
+ if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
4035
+ try {
4036
+ parsed.host = new URL("http://" + parsed.host).hostname;
4037
+ } catch (e) {
4038
+ parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
4039
+ return true;
4040
+ }
4041
+ }
4042
+ return false;
4043
+ }
3788
4044
  function parseWithStatus(uri, opts) {
3789
4045
  const options = Object.assign({}, opts);
3790
4046
  const parsed = {
@@ -3797,6 +4053,11 @@ var require_fast_uri = __commonJS({
3797
4053
  fragment: void 0
3798
4054
  };
3799
4055
  let malformedAuthorityOrPort = false;
4056
+ let malformedPercentEncoding = false;
4057
+ let malformedSchemeSpecific = false;
4058
+ let malformedHost = false;
4059
+ let malformedIPLiteral = false;
4060
+ let malformedScheme = false;
3800
4061
  let isIP = false;
3801
4062
  if (options.reference === "suffix") {
3802
4063
  if (options.scheme) {
@@ -3833,6 +4094,19 @@ var require_fast_uri = __commonJS({
3833
4094
  parsed.path = matches[6] || "";
3834
4095
  parsed.query = matches[7];
3835
4096
  parsed.fragment = matches[8];
4097
+ if (parsed.scheme !== void 0) {
4098
+ const decodedScheme = unescape(parsed.scheme);
4099
+ if (VALID_SCHEME.test(decodedScheme)) {
4100
+ parsed.scheme = decodedScheme.toLowerCase();
4101
+ } else {
4102
+ parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
4103
+ malformedScheme = true;
4104
+ }
4105
+ }
4106
+ malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
4107
+ if (malformedPercentEncoding) {
4108
+ parsed.error = parsed.error || "URI contains malformed percent-encoding.";
4109
+ }
3836
4110
  if (isNaN(parsed.port)) {
3837
4111
  parsed.port = matches[5];
3838
4112
  }
@@ -3844,9 +4118,16 @@ var require_fast_uri = __commonJS({
3844
4118
  if (parsed.host) {
3845
4119
  const ipv4result = isIPv4(parsed.host);
3846
4120
  if (ipv4result === false) {
4121
+ const bracketedIPLiteral = isIPLiteral(parsed.host);
4122
+ const hasIPLiteralBracket = parsed.host.indexOf("[") !== -1 || parsed.host.indexOf("]") !== -1;
3847
4123
  const ipv6result = normalizeIPv6(parsed.host);
3848
- parsed.host = ipv6result.host.toLowerCase();
3849
- isIP = ipv6result.isIPV6;
4124
+ isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
4125
+ malformedIPLiteral = hasIPLiteralBracket && (!bracketedIPLiteral || ipv6result.error === true);
4126
+ parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
4127
+ if (malformedIPLiteral) {
4128
+ parsed.error = parsed.error || "URI host is malformed.";
4129
+ malformedAuthorityOrPort = true;
4130
+ }
3850
4131
  } else {
3851
4132
  isIP = true;
3852
4133
  }
@@ -3864,42 +4145,36 @@ var require_fast_uri = __commonJS({
3864
4145
  parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
3865
4146
  }
3866
4147
  const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
3867
- if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
3868
- if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
3869
- try {
3870
- parsed.host = new URL("http://" + parsed.host).hostname;
3871
- } catch (e) {
3872
- parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
3873
- }
3874
- }
4148
+ if (!malformedIPLiteral) {
4149
+ malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
3875
4150
  }
3876
4151
  if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
3877
4152
  if (uri.indexOf("%") !== -1) {
3878
- if (parsed.scheme !== void 0) {
3879
- parsed.scheme = unescape(parsed.scheme);
3880
- }
3881
- if (parsed.host !== void 0) {
3882
- parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
4153
+ if (parsed.host !== void 0 && !malformedIPLiteral) {
4154
+ const host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
4155
+ parsed.host = reescapeHostDelimiters(host, isIP);
3883
4156
  }
3884
4157
  }
3885
4158
  if (parsed.path) {
3886
4159
  parsed.path = normalizePathEncoding(parsed.path);
3887
4160
  }
4161
+ if (parsed.query) {
4162
+ parsed.query = normalizeQueryFragmentEncoding(parsed.query);
4163
+ }
3888
4164
  if (parsed.fragment) {
3889
- try {
3890
- parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
3891
- } catch {
3892
- parsed.error = parsed.error || "URI malformed";
3893
- }
4165
+ parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
3894
4166
  }
3895
4167
  }
3896
4168
  if (schemeHandler && schemeHandler.parse) {
3897
4169
  schemeHandler.parse(parsed, options);
4170
+ if (schemeHandler === SCHEMES.urn && parsed.nid === void 0) {
4171
+ malformedSchemeSpecific = true;
4172
+ }
3898
4173
  }
3899
4174
  } else {
3900
4175
  parsed.error = parsed.error || "URI can not be parsed.";
3901
4176
  }
3902
- return { parsed, malformedAuthorityOrPort };
4177
+ return { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme };
3903
4178
  }
3904
4179
  function parse3(uri, opts) {
3905
4180
  return parseWithStatus(uri, opts).parsed;
@@ -3908,20 +4183,28 @@ var require_fast_uri = __commonJS({
3908
4183
  return normalizeStringWithStatus(uri, opts).normalized;
3909
4184
  }
3910
4185
  function normalizeStringWithStatus(uri, opts) {
3911
- const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
4186
+ const { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
3912
4187
  return {
3913
- normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
3914
- malformedAuthorityOrPort
4188
+ normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed, opts),
4189
+ malformedAuthorityOrPort,
4190
+ malformedPercentEncoding,
4191
+ malformedSchemeSpecific,
4192
+ malformedHost,
4193
+ malformedScheme
3915
4194
  };
3916
4195
  }
3917
4196
  function normalizeComparableURI(uri, opts) {
3918
- if (typeof uri === "string") {
3919
- const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
3920
- return malformedAuthorityOrPort ? void 0 : normalized;
4197
+ if (typeof uri !== "string" && typeof uri !== "object") {
4198
+ return void 0;
3921
4199
  }
3922
- if (typeof uri === "object") {
3923
- return serialize(uri, opts);
4200
+ let value;
4201
+ try {
4202
+ value = typeof uri === "string" ? uri : serialize(uri, opts);
4203
+ } catch {
4204
+ return void 0;
3924
4205
  }
4206
+ const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
4207
+ return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? void 0 : normalized;
3925
4208
  }
3926
4209
  var fastUri = {
3927
4210
  SCHEMES,
@@ -31276,9 +31559,13 @@ function isOptedIn(config2, directory) {
31276
31559
  const pathMap = config2.mapPathToBank;
31277
31560
  return Boolean(pathMap && directories.some((candidate) => mapLookup(pathMap, candidate)));
31278
31561
  }
31279
- function deriveBankId(config2, directory, harness = "coding", sessionRoot) {
31562
+ function mappedBank(config2, directory, sessionRoot) {
31280
31563
  const pathMap = config2.mapPathToBank;
31281
- const mapped = directory && pathMap ? lookupDirectories(config2, directory, sessionRoot).map((candidate) => mapLookup(pathMap, candidate)).find((bank) => bank !== void 0) : void 0;
31564
+ if (!directory || !pathMap) return void 0;
31565
+ return lookupDirectories(config2, directory, sessionRoot).map((candidate) => mapLookup(pathMap, candidate)).find((bank) => bank !== void 0);
31566
+ }
31567
+ function deriveBankId(config2, directory, harness = "coding", sessionRoot) {
31568
+ const mapped = mappedBank(config2, directory, sessionRoot);
31282
31569
  if (mapped) return mapped;
31283
31570
  const dynamic = config2.dynamicBankId ?? !config2.bankId;
31284
31571
  if (!dynamic) return config2.bankId || DEFAULT_BANK_NAME;
@@ -31306,6 +31593,7 @@ function deriveBankIdOrSkip(config2, directory, harness = "coding", sessionRoot)
31306
31593
  }
31307
31594
 
31308
31595
  // src/core/missions.ts
31596
+ import { createHash } from "crypto";
31309
31597
  var GIT_MISSION = "You are ingesting a single git commit: its message and its full diff. Extract the concrete technical DECISION and the CAUSE/INVARIANT it encodes, bound to the specific code entities (functions, methods, files) and behaviors it changes. Preserve exact identifiers, paths, and literal values verbatim. Preserve the 'REF-ID: <token>' marker verbatim in every fact. Capture both WHAT changed and WHY. Issue/PR references (#123, GH-123, PROJ-123) are load-bearing: keep them VERBATIM in the fact text and emit each as an ENTITY, so a later question about that issue or PR retrieves this decision.";
31310
31598
  var GITLOG_MISSION = "You are ingesting an aggregated block of git commit MESSAGES ONLY (no diffs) \u2014 the project's recent commit-message history, newest first. Extract the project's INITIATIVES, FEATURES, ENHANCEMENTS, and notable changes or THEMES over time \u2014 what the project has been working on and how it has evolved. Do NOT extract per-line code detail (there is no diff to draw it from). Group related commits into a coherent initiative/theme where the messages make that clear; preserve exact identifiers and literal values verbatim when quoting a subject line. Keep issue/PR references (#123, GH-123) VERBATIM and emit each as an ENTITY \u2014 they are how future sessions will ask about this work.";
31311
31599
  var CONVERSATION_MISSION = `You are ingesting a developer conversation as a JSONL transcript (one {role, content} turn per line): the user's requests, the assistant's narration, and compact 'action' turns naming each tool use and its target (e.g. "Edit boltons/strutils.py") with no arguments or outputs. It may be a SHORT decision chat or a LONG working session \u2014 scale the facts to the substance, never to the message count. Extract the FEWEST facts that capture the OUTCOME: the settled DECISIONS and their exact rules/values (quote literals VERBATIM); concrete CHANGES to specific code entities; problems and how they were resolved; conventions or invariants established; at most one fact for a notable REJECTED alternative ('initially proposed X, changed to Y because Z'). A short decision chat usually yields 1-2 facts; a substantial working session several. CRITICAL: a conversation REVISES itself \u2014 record ONLY the FINAL state as what is in effect; a superseded proposal appears ONLY inside the rejected fact, NEVER as its own 'decided' fact; if the same setting changes several times keep only the LAST, and make unmistakably clear which choice WON. Do NOT emit one fact per message, per intermediate proposal, or per action turn. Keep issue/PR references (#123, GH-123) VERBATIM and emit each as an ENTITY. Preserve the 'REF-ID: <token>' marker verbatim in every fact. Do not invent; capture only what was actually settled.`;
@@ -31417,6 +31705,56 @@ function pagesFor(project) {
31417
31705
  var PAGE_MAX_TOKENS = 4096;
31418
31706
  var PAGE_TAGS_MATCH = "all";
31419
31707
  var PAGE_FACT_TYPES = ["world", "experience", "observation"];
31708
+ var CRON_FIELD_RANGES = [
31709
+ [0, 59],
31710
+ // minute
31711
+ [0, 23],
31712
+ // hour
31713
+ [1, 31],
31714
+ // day of month
31715
+ [1, 12],
31716
+ // month
31717
+ [0, 6]
31718
+ // day of week
31719
+ ];
31720
+ var HASHED_FIELD = /^H(?:\((\d+)-(\d+)\))?$/;
31721
+ function isHashedCron(cron) {
31722
+ return /(^|\s)H/.test(cron);
31723
+ }
31724
+ function parseHashedCron(cron) {
31725
+ const fields = cron.trim().split(/\s+/);
31726
+ if (fields.length !== CRON_FIELD_RANGES.length) return void 0;
31727
+ for (const [i, field] of fields.entries()) {
31728
+ if (!field.startsWith("H")) continue;
31729
+ const m = HASHED_FIELD.exec(field);
31730
+ if (!m) return void 0;
31731
+ if (m[1] === void 0) continue;
31732
+ const [lo, hi] = [Number(m[1]), Number(m[2])];
31733
+ const [min, max] = CRON_FIELD_RANGES[i];
31734
+ if (lo > hi || lo < min || hi > max) return void 0;
31735
+ }
31736
+ return fields;
31737
+ }
31738
+ function hashedValue(seed, field, lo, hi) {
31739
+ const digest = createHash("sha256").update(`${seed}\0${field}`).digest();
31740
+ return lo + digest.readUInt32BE(0) % (hi - lo + 1);
31741
+ }
31742
+ function expandCronHash(cron, seed) {
31743
+ if (!isHashedCron(cron)) return cron;
31744
+ const fields = parseHashedCron(cron);
31745
+ if (!fields) return cron;
31746
+ return fields.map((field, i) => {
31747
+ const m = HASHED_FIELD.exec(field);
31748
+ if (!m) return field;
31749
+ const [lo, hi] = m[1] === void 0 ? CRON_FIELD_RANGES[i] : [Number(m[1]), Number(m[2])];
31750
+ return String(hashedValue(seed, i, lo, hi));
31751
+ }).join(" ");
31752
+ }
31753
+ function pageTriggerFor(trigger, bank, page) {
31754
+ const cron = trigger.refresh_cron;
31755
+ if (!cron || !isHashedCron(cron)) return trigger;
31756
+ return { ...trigger, refresh_cron: expandCronHash(cron, `${bank}\0${page}`) };
31757
+ }
31420
31758
  function buildPageTrigger(cfg = {}) {
31421
31759
  const base = { fact_types: PAGE_FACT_TYPES, tags_match: PAGE_TAGS_MATCH };
31422
31760
  switch (cfg.pageTriggerType) {
@@ -31951,7 +32289,9 @@ var HindsightClient = class {
31951
32289
  source_query: page.source_query,
31952
32290
  tags: page.tags,
31953
32291
  max_tokens: PAGE_MAX_TOKENS,
31954
- trigger: pageTrigger
32292
+ // Resolved HERE, not in `buildPageTrigger`: a hashed cron (`H`) needs the page's identity,
32293
+ // and one trigger is built per session for all of them.
32294
+ trigger: pageTriggerFor(pageTrigger, this.bank, page.name)
31955
32295
  };
31956
32296
  if (!hit) {
31957
32297
  const r = await this.req("POST", this.bankUrl("/knowledge-base/pages"), body, [409]);
@@ -31989,7 +32329,7 @@ var HindsightClient = class {
31989
32329
  }
31990
32330
  }
31991
32331
  this.log(
31992
- `[bank] knowledge pages seeded on ${this.bank}: ${created} created, ${updated} re-synced, ${pages.length - created - updated} unchanged`
32332
+ `[bank] knowledge pages seeded on ${this.bank} (scoped to ${this.project ?? this.bank}): ${created} created, ${updated} re-synced, ${pages.length - created - updated} unchanged`
31993
32333
  );
31994
32334
  }
31995
32335
  /** URL/id-safe slug: lowercase, non-alphanumerics → "-", trim dashes, cap length; fallback "initiative". */
@@ -32018,7 +32358,7 @@ var HindsightClient = class {
32018
32358
  source_query: `Summarize the "${args.title}" initiative: what is being built or changed and why, and its current state \u2014 drawn from the project's memory.`,
32019
32359
  parent_id: folderId,
32020
32360
  tags: ["knowledge:feature-work"],
32021
- trigger: args.pageTrigger ?? buildPageTrigger()
32361
+ trigger: pageTriggerFor(args.pageTrigger ?? buildPageTrigger(), this.bank, args.title)
32022
32362
  });
32023
32363
  try {
32024
32364
  const j = await r.json();
@@ -32063,10 +32403,11 @@ var DEFAULT_DAEMON_PROFILE = "coding-agent";
32063
32403
  function resolvePageTriggerType(raw) {
32064
32404
  if (raw.pageTriggerType === "manual") return "manual";
32065
32405
  if (raw.pageTriggerType === "cron") {
32066
- if (raw.pageTriggerCron?.trim()) return "cron";
32406
+ const cron = raw.pageTriggerCron?.trim();
32407
+ if (cron && (!isHashedCron(cron) || parseHashedCron(cron))) return "cron";
32067
32408
  log.warn(
32068
32409
  "config",
32069
- 'pageTriggerType "cron" needs pageTriggerCron (UTC 5-field, e.g. "0 3 * * *") \u2014 falling back to "auto-refresh"'
32410
+ cron ? `pageTriggerCron ${JSON.stringify(cron)} has a malformed hashed field \u2014 write \`H\` or \`H(<lo>-<hi>)\` within the field's own range, e.g. "H H(0-5) * * *" \u2014 falling back to "auto-refresh"` : 'pageTriggerType "cron" needs pageTriggerCron (UTC 5-field, e.g. "H H * * *") \u2014 falling back to "auto-refresh"'
32070
32411
  );
32071
32412
  }
32072
32413
  return "auto-refresh";