glimmervoid 0.49.1-next.555 → 0.49.1-next.557

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 (83) hide show
  1. package/dist/chunks/{main-CMqiFrzy.js → main-Do8FQTAe.js} +860 -668
  2. package/dist/client/assets/{benchmark-panel-dZq4kb0z.js → benchmark-panel-BZ-BguIq.js} +1 -1
  3. package/dist/client/assets/benchmark-panel-BZ-BguIq.js.br +0 -0
  4. package/dist/client/assets/{boards-view-LwVCmJDW.js → boards-view-BzihP-XL.js} +1 -1
  5. package/dist/client/assets/boards-view-BzihP-XL.js.br +0 -0
  6. package/dist/client/assets/{community-panel-DnOsfeh_.js → community-panel-Cgc462sA.js} +1 -1
  7. package/dist/client/assets/community-panel-Cgc462sA.js.br +0 -0
  8. package/dist/client/assets/{dialogs-CPHIfdbC.js → dialogs-BwFIl6cl.js} +1 -1
  9. package/dist/client/assets/dialogs-BwFIl6cl.js.br +0 -0
  10. package/dist/client/assets/{doc-editor-ui-B7bFdyFH.js → doc-editor-ui-Ck3eFQPb.js} +1 -1
  11. package/dist/client/assets/doc-editor-ui-Ck3eFQPb.js.br +0 -0
  12. package/dist/client/assets/{feature-hint-KM4uMbiR.js → feature-hint-CZALOUFK.js} +1 -1
  13. package/dist/client/assets/feature-hint-CZALOUFK.js.br +0 -0
  14. package/dist/client/assets/{first-run-checklist-CqI73zXI.js → first-run-checklist-B8vnsj0B.js} +1 -1
  15. package/dist/client/assets/first-run-checklist-B8vnsj0B.js.br +0 -0
  16. package/dist/client/assets/{hooks-panel-CYTFjtTF.js → hooks-panel-D28q72ql.js} +1 -1
  17. package/dist/client/assets/hooks-panel-D28q72ql.js.br +0 -0
  18. package/dist/client/assets/{index-D1z6rexP.js → index-CvF05bPl.js} +5 -5
  19. package/dist/client/assets/index-CvF05bPl.js.br +0 -0
  20. package/dist/client/assets/{issues-panel-BpJbRxhl.js → issues-panel-Bl3v4NbY.js} +1 -1
  21. package/dist/client/assets/issues-panel-Bl3v4NbY.js.br +0 -0
  22. package/dist/client/assets/{my-prs-panel-CPpXWTdZ.js → my-prs-panel-DFM8wSWr.js} +1 -1
  23. package/dist/client/assets/my-prs-panel-DFM8wSWr.js.br +0 -0
  24. package/dist/client/assets/{nyan-cat-BrCD2Pjs.js → nyan-cat-CPeIHjXw.js} +1 -1
  25. package/dist/client/assets/nyan-cat-CPeIHjXw.js.br +0 -0
  26. package/dist/client/assets/{phone-shell-DU-3OL7a.js → phone-shell-BBs0QRL6.js} +1 -1
  27. package/dist/client/assets/phone-shell-BBs0QRL6.js.br +0 -0
  28. package/dist/client/assets/{plan-face-rUTsZUZV.js → plan-face-BQds9fox.js} +1 -1
  29. package/dist/client/assets/plan-face-BQds9fox.js.br +0 -0
  30. package/dist/client/assets/{plan-render-CcIqsihp.js → plan-render-CK3sQycN.js} +1 -1
  31. package/dist/client/assets/plan-render-CK3sQycN.js.br +0 -0
  32. package/dist/client/assets/{pr-queue-columns-jn-Qu_Db.js → pr-queue-columns-n1Ttll-m.js} +1 -1
  33. package/dist/client/assets/pr-queue-columns-n1Ttll-m.js.br +0 -0
  34. package/dist/client/assets/{radar-panel-CFNh1oGB.js → radar-panel-CHHJyadx.js} +1 -1
  35. package/dist/client/assets/radar-panel-CHHJyadx.js.br +0 -0
  36. package/dist/client/assets/{repo-roots-adder-Z8IWMaZq.js → repo-roots-adder-yqnaCW9l.js} +1 -1
  37. package/dist/client/assets/repo-roots-adder-yqnaCW9l.js.br +0 -0
  38. package/dist/client/assets/{resume-dialog-BKuAmsKB.js → resume-dialog-BxJlO6eS.js} +1 -1
  39. package/dist/client/assets/resume-dialog-BxJlO6eS.js.br +0 -0
  40. package/dist/client/assets/{review-queue-panel-BsiCLhWE.js → review-queue-panel-D4qOJTf3.js} +1 -1
  41. package/dist/client/assets/review-queue-panel-D4qOJTf3.js.br +0 -0
  42. package/dist/client/assets/{settings-panel-CChRKHHY.js → settings-panel-cmlk9MDH.js} +2 -2
  43. package/dist/client/assets/settings-panel-cmlk9MDH.js.br +0 -0
  44. package/dist/client/assets/{shown-face-UpOwJVf7.js → shown-face-EIKY1wEl.js} +1 -1
  45. package/dist/client/assets/shown-face-EIKY1wEl.js.br +0 -0
  46. package/dist/client/assets/{team-review-queue-row-Bx-4bv1G.js → team-review-queue-row-C0iHzeft.js} +1 -1
  47. package/dist/client/assets/team-review-queue-row-C0iHzeft.js.br +0 -0
  48. package/dist/client/assets/{trace-panel-Du_EYJzK.js → trace-panel-BTBllQi-.js} +1 -1
  49. package/dist/client/assets/trace-panel-BTBllQi-.js.br +0 -0
  50. package/dist/client/assets/{usage-panel-CA9tHAgZ.js → usage-panel-C4DjJRIB.js} +1 -1
  51. package/dist/client/assets/usage-panel-C4DjJRIB.js.br +0 -0
  52. package/dist/client/assets/{your-day-tip-mmWi2QMC.js → your-day-tip-CDGGkrCd.js} +1 -1
  53. package/dist/client/assets/your-day-tip-CDGGkrCd.js.br +0 -0
  54. package/dist/client/index.html +1 -1
  55. package/dist/client/index.html.br +0 -0
  56. package/dist/server/index.js +1 -1
  57. package/package.json +1 -1
  58. package/dist/client/assets/benchmark-panel-dZq4kb0z.js.br +0 -0
  59. package/dist/client/assets/boards-view-LwVCmJDW.js.br +0 -0
  60. package/dist/client/assets/community-panel-DnOsfeh_.js.br +0 -0
  61. package/dist/client/assets/dialogs-CPHIfdbC.js.br +0 -0
  62. package/dist/client/assets/doc-editor-ui-B7bFdyFH.js.br +0 -0
  63. package/dist/client/assets/feature-hint-KM4uMbiR.js.br +0 -0
  64. package/dist/client/assets/first-run-checklist-CqI73zXI.js.br +0 -0
  65. package/dist/client/assets/hooks-panel-CYTFjtTF.js.br +0 -0
  66. package/dist/client/assets/index-D1z6rexP.js.br +0 -0
  67. package/dist/client/assets/issues-panel-BpJbRxhl.js.br +0 -0
  68. package/dist/client/assets/my-prs-panel-CPpXWTdZ.js.br +0 -0
  69. package/dist/client/assets/nyan-cat-BrCD2Pjs.js.br +0 -0
  70. package/dist/client/assets/phone-shell-DU-3OL7a.js.br +0 -0
  71. package/dist/client/assets/plan-face-rUTsZUZV.js.br +0 -0
  72. package/dist/client/assets/plan-render-CcIqsihp.js.br +0 -0
  73. package/dist/client/assets/pr-queue-columns-jn-Qu_Db.js.br +0 -0
  74. package/dist/client/assets/radar-panel-CFNh1oGB.js.br +0 -0
  75. package/dist/client/assets/repo-roots-adder-Z8IWMaZq.js.br +0 -0
  76. package/dist/client/assets/resume-dialog-BKuAmsKB.js.br +0 -0
  77. package/dist/client/assets/review-queue-panel-BsiCLhWE.js.br +0 -0
  78. package/dist/client/assets/settings-panel-CChRKHHY.js.br +0 -0
  79. package/dist/client/assets/shown-face-UpOwJVf7.js.br +0 -0
  80. package/dist/client/assets/team-review-queue-row-Bx-4bv1G.js.br +0 -0
  81. package/dist/client/assets/trace-panel-Du_EYJzK.js.br +0 -0
  82. package/dist/client/assets/usage-panel-CA9tHAgZ.js.br +0 -0
  83. package/dist/client/assets/your-day-tip-mmWi2QMC.js.br +0 -0
@@ -34767,7 +34767,7 @@ async function reapTeamReviewProcesses({ ownedDirectories, reviewRoots, scope, l
34767
34767
  }
34768
34768
  }
34769
34769
  //#endregion
34770
- //#region server/github/team-review-poller.ts
34770
+ //#region server/github/team-review-poller/team-review-poller-context.ts
34771
34771
  var TEAM_REVIEW_RATE_LIMIT_RESOURCES = [
34772
34772
  "search",
34773
34773
  "graphql",
@@ -34782,56 +34782,14 @@ var REQUEUEABLE_STATUSES = /* @__PURE__ */ new Set([
34782
34782
  "discarded",
34783
34783
  "posted"
34784
34784
  ]);
34785
- function createTeamReviewPoller(deps) {
34786
- const { org, teams, github, store, spawnReview, discardResumable = async () => {}, readState = async () => ({}), writeState = async () => {}, beforeStart = async () => {}, setIntervalFn = DEFAULT_TIMER_FNS.setIntervalFn, clearIntervalFn = DEFAULT_TIMER_FNS.clearIntervalFn, setTimeoutFn = DEFAULT_TIMER_FNS.setTimeoutFn, clearTimeoutFn = DEFAULT_TIMER_FNS.clearTimeoutFn, log = console, telemetry = null, onTickComplete = () => {}, now = () => Date.now() } = deps;
34787
- const maxConcurrentReviews = deps.maxConcurrentReviews ?? 2;
34788
- const reReviewAfterMs = deps.reReviewAfterMs ?? 864e5;
34789
- const skipIdleAfterMs = deps.skipIdleAfterMs ?? 12096e5;
34790
- let state = {};
34791
- let self = null;
34792
- let teamProfile = null;
34793
- const progressByKey = /* @__PURE__ */ new Map();
34794
- const reviewCancellersByKey = /* @__PURE__ */ new Map();
34795
- const notMineWhileReviewingKeys = /* @__PURE__ */ new Set();
34796
- let waitingForSlot = [];
34785
+ //#endregion
34786
+ //#region server/github/team-review-poller/team-review-status-reporter.ts
34787
+ function createTeamReviewStatusReporter(context) {
34788
+ const { onTickComplete, now, setTimeoutFn, clearTimeoutFn, runtime, progressByKey, loop } = context;
34797
34789
  let lastEmitAt = Number.NEGATIVE_INFINITY;
34798
34790
  let pendingProgressEmit = null;
34799
- let hasSlotFreedSinceSlotCount = false;
34800
- let pollingError = null;
34801
- const watches = /* @__PURE__ */ new Map();
34802
- let hasLoadedState = false;
34803
- let lastRebuildQueueSignature = null;
34804
- let tickRateLimitWaitMs = null;
34805
- let teamCandidateKeys = /* @__PURE__ */ new Set();
34806
- const loop = createTickLoop({
34807
- tag: TEAM_REVIEW_LANE_ID,
34808
- intervalMs: (deps.intervalMinutes ?? 15) * 6e4,
34809
- tick: async () => {
34810
- try {
34811
- return await runTick();
34812
- } catch (error) {
34813
- pollingError = errorMessage(error);
34814
- log.warn(`[${TEAM_REVIEW_LANE_ID}] poll failed: ${pollingError}`);
34815
- return rateLimitedOutcome();
34816
- }
34817
- },
34818
- quickRetries: true,
34819
- now,
34820
- setTimeoutFn,
34821
- clearTimeoutFn,
34822
- onScheduleChange: emitStatus,
34823
- rateLimitWaitMs: () => store.rateLimitWaitMs(now(), TEAM_REVIEW_RATE_LIMIT_RESOURCES),
34824
- writeState: () => writeState(state),
34825
- setIntervalFn,
34826
- clearIntervalFn,
34827
- clock: storeReadingLaneClock(deps.clock),
34828
- firstTickDelayMs: deps.firstTickDelayMs,
34829
- backoffMaxMs: GITHUB_RATE_LIMIT_WINDOW_MS,
34830
- log
34831
- });
34832
- const persist = () => loop.persist();
34833
34791
  function inFlightKeys() {
34834
- return Object.keys(state).filter((key) => state[key]?.inFlight);
34792
+ return Object.keys(runtime.state).filter((key) => runtime.state[key]?.inFlight);
34835
34793
  }
34836
34794
  function inFlightReviews() {
34837
34795
  return inFlightKeys().flatMap((key) => {
@@ -34851,12 +34809,12 @@ function createTeamReviewPoller(deps) {
34851
34809
  ...teamReviewStatus({
34852
34810
  ts: now(),
34853
34811
  configured: true,
34854
- team: teamProfile,
34855
- drafts: draftsNewestFirst(state),
34812
+ team: runtime.teamProfile,
34813
+ drafts: draftsNewestFirst(runtime.state),
34856
34814
  inFlight: inFlightReviews(),
34857
- queued: waitingForSlot.filter((candidate) => !state[candidate.key]?.inFlight)
34815
+ queued: runtime.waitingForSlot.filter((candidate) => !runtime.state[candidate.key]?.inFlight)
34858
34816
  }),
34859
- error: pollingError,
34817
+ error: runtime.pollingError,
34860
34818
  ...loop.scheduleStatus()
34861
34819
  });
34862
34820
  }
@@ -34881,8 +34839,195 @@ function createTeamReviewPoller(deps) {
34881
34839
  emitStatus();
34882
34840
  }, waitMs);
34883
34841
  }
34842
+ return {
34843
+ inFlightKeys,
34844
+ cancelPendingProgressEmit,
34845
+ emitStatus,
34846
+ progressReporter
34847
+ };
34848
+ }
34849
+ //#endregion
34850
+ //#region server/github/team-review-poller/team-review-candidate-search.ts
34851
+ function createTeamReviewCandidateSearch(context) {
34852
+ const { org, teams, store, discardResumable, now, skipIdleAfterMs, runtime, watches, loop } = context;
34853
+ function closedEntryKeys() {
34854
+ const prs = store.getSnapshot().prs;
34855
+ return new Set(Object.keys(runtime.state).filter((key) => {
34856
+ const pr = prs[key.toLowerCase()];
34857
+ return !runtime.state[key]?.inFlight && pr !== void 0 && pr.state !== "OPEN";
34858
+ }));
34859
+ }
34860
+ function watchDeparted(candidateKeys) {
34861
+ const departedKeys = Object.keys(runtime.state).filter((key) => !candidateKeys.has(key) && !runtime.state[key]?.inFlight);
34862
+ store.setWatchedKeys("team-review-departed", departedKeys.map((key) => key.toLowerCase()));
34863
+ }
34864
+ async function pruneDeparted(candidateKeys, isComplete) {
34865
+ let isDirty = false;
34866
+ watchDeparted(candidateKeys);
34867
+ const closedKeys = closedEntryKeys();
34868
+ for (const [key, entry] of Object.entries(runtime.state)) {
34869
+ const isClosed = closedKeys.has(key);
34870
+ if (candidateKeys.has(key) || !isComplete && !isClosed) continue;
34871
+ if (entry.resumable) {
34872
+ await discardResumable(entry.resumable);
34873
+ entry.resumable = null;
34874
+ isDirty = true;
34875
+ }
34876
+ if (!shouldPruneEntry$1(entry, false, now(), isClosed)) continue;
34877
+ delete runtime.state[key];
34878
+ isDirty = true;
34879
+ }
34880
+ return isDirty;
34881
+ }
34882
+ async function collectCandidates() {
34883
+ const firstTeam = teams[0];
34884
+ if (!firstTeam) {
34885
+ unregisterWatches();
34886
+ return null;
34887
+ }
34888
+ if (runtime.teamProfile === null) {
34889
+ const profileRead = await store.requestTeamProfile(firstTeam.org, firstTeam.slug, "no-wait");
34890
+ if (profileRead.isRateLimited) {
34891
+ runtime.tickRateLimitWaitMs = profileRead.waitMs;
34892
+ return null;
34893
+ }
34894
+ runtime.teamProfile = profileRead.value;
34895
+ }
34896
+ if (runtime.self === null) {
34897
+ const viewerRead = await store.requestViewer("no-wait");
34898
+ if (viewerRead.isRateLimited) {
34899
+ runtime.tickRateLimitWaitMs = viewerRead.waitMs;
34900
+ return null;
34901
+ }
34902
+ runtime.self = viewerRead.value;
34903
+ }
34904
+ const viewer = runtime.self;
34905
+ if (viewer === null) return null;
34906
+ const memberLists = [];
34907
+ for (const team of teams) {
34908
+ const membersRead = await store.requestTeamMembers(team.org, team.slug, "no-wait");
34909
+ if (membersRead.isRateLimited) {
34910
+ runtime.tickRateLimitWaitMs = membersRead.waitMs;
34911
+ return null;
34912
+ }
34913
+ memberLists.push(membersRead.value);
34914
+ }
34915
+ const isMembershipComplete = memberLists.every((members) => members !== null);
34916
+ const fetchedMemberLists = memberLists.map((members) => members ?? []);
34917
+ if (fetchedMemberLists.every((members) => members.length === 0)) {
34918
+ if (isMembershipComplete) unregisterWatches();
34919
+ return null;
34920
+ }
34921
+ if (loop.isStopped()) return null;
34922
+ registerWatches(orgSearchPlans(org, teams, fetchedMemberLists, viewer));
34923
+ const collected = candidatesFromSnapshot(viewer);
34924
+ runtime.teamCandidateKeys = collected.teamCandidateKeys;
34925
+ return {
34926
+ candidates: collected.candidates,
34927
+ isComplete: isMembershipComplete && collected.isComplete
34928
+ };
34929
+ }
34930
+ function registerWatches(searchPlans) {
34931
+ const nextWatches = /* @__PURE__ */ new Map();
34932
+ for (const plan of searchPlans) {
34933
+ nextWatches.set(`team-review-direct:${plan.org.toLowerCase()}`, {
34934
+ qualifiers: `is:open draft:false org:${plan.org} user-review-requested:@me`,
34935
+ source: "direct"
34936
+ });
34937
+ for (let index = 0; index < plan.authors.length; index += 5) {
34938
+ const authors = plan.authors.slice(index, index + 5).map((author) => `author:${author}`).join(" ");
34939
+ nextWatches.set(`team-review-authored:${plan.org.toLowerCase()}:${index / 5}`, {
34940
+ qualifiers: `is:open draft:false org:${plan.org} ${authors}`,
34941
+ source: "authored"
34942
+ });
34943
+ }
34944
+ }
34945
+ for (const team of teams) nextWatches.set(`team-review-team:${team.org.toLowerCase()}/${team.slug.toLowerCase()}`, {
34946
+ qualifiers: `is:open draft:false org:${team.org} team-review-requested:${team.org}/${team.slug}`,
34947
+ source: "team"
34948
+ });
34949
+ for (const name of watches.keys()) if (!nextWatches.has(name)) store.unregisterWatch(name);
34950
+ for (const [name, watch] of nextWatches) if (watches.get(name)?.qualifiers !== watch.qualifiers) store.registerWatch({
34951
+ name,
34952
+ qualifiers: watch.qualifiers,
34953
+ needsDetail: true
34954
+ });
34955
+ watches.clear();
34956
+ for (const [name, watch] of nextWatches) watches.set(name, watch);
34957
+ }
34958
+ function askedForKeys() {
34959
+ return Object.keys(runtime.state).filter((key) => runtime.state[key]?.requestedAt !== void 0);
34960
+ }
34961
+ function isTeamCandidate(key) {
34962
+ return runtime.teamCandidateKeys.has(key.toLowerCase());
34963
+ }
34964
+ function askedForSlotsInUse() {
34965
+ return askedForKeys().filter((key) => runtime.state[key]?.draft?.status !== "posted" && !isTeamCandidate(key)).length;
34966
+ }
34967
+ function watchAskedFor() {
34968
+ store.setWatchedKeys(ASKED_FOR_WATCH_OWNER, askedForKeys());
34969
+ }
34970
+ function candidatesFromSnapshot(viewer) {
34971
+ const snapshot = store.getSnapshot();
34972
+ let isAskedForComplete = true;
34973
+ const askedFor = askedForKeys().flatMap((key) => {
34974
+ const pr = snapshot.prs[key.toLowerCase()];
34975
+ if (pr) return [pr];
34976
+ const requestedAt = runtime.state[key]?.requestedAt ?? 0;
34977
+ if (now() - requestedAt < 36e5) isAskedForComplete = false;
34978
+ return [];
34979
+ });
34980
+ const prsBySource = {
34981
+ direct: [],
34982
+ team: [],
34983
+ authored: []
34984
+ };
34985
+ let isComplete = true;
34986
+ for (const [name, { source }] of watches) {
34987
+ const watch = snapshot.watches[name];
34988
+ if (!watch?.isLoaded || !watch.isComplete) isComplete = false;
34989
+ for (const key of watch?.keys ?? []) {
34990
+ const pr = snapshot.prs[key];
34991
+ if (!pr) {
34992
+ isComplete = false;
34993
+ continue;
34994
+ }
34995
+ prsBySource[source].push(pr);
34996
+ }
34997
+ }
34998
+ return {
34999
+ ...selectCandidates(prsBySource.direct, prsBySource.team, prsBySource.authored, {
35000
+ self: viewer,
35001
+ nowMs: now(),
35002
+ skipIdleAfterMs,
35003
+ askedFor
35004
+ }),
35005
+ isComplete: isComplete && isAskedForComplete
35006
+ };
35007
+ }
35008
+ function unregisterWatches() {
35009
+ for (const name of watches.keys()) store.unregisterWatch(name);
35010
+ watches.clear();
35011
+ store.setWatchedKeys("team-review-departed", []);
35012
+ store.setWatchedKeys(ASKED_FOR_WATCH_OWNER, []);
35013
+ }
35014
+ return {
35015
+ closedEntryKeys,
35016
+ pruneDeparted,
35017
+ collectCandidates,
35018
+ isTeamCandidate,
35019
+ askedForSlotsInUse,
35020
+ watchAskedFor,
35021
+ candidatesFromSnapshot,
35022
+ unregisterWatches
35023
+ };
35024
+ }
35025
+ //#endregion
35026
+ //#region server/github/team-review-poller/team-review-head-planning.ts
35027
+ function createTeamReviewHeadPlanning(context) {
35028
+ const { store, now, reReviewAfterMs, runtime } = context;
34884
35029
  function entryFor(key) {
34885
- const existing = state[key];
35030
+ const existing = runtime.state[key];
34886
35031
  if (existing) return existing;
34887
35032
  const created = {
34888
35033
  draft: null,
@@ -34891,78 +35036,21 @@ function createTeamReviewPoller(deps) {
34891
35036
  reviewAttempts: 0,
34892
35037
  updatedAt: now()
34893
35038
  };
34894
- state[key] = created;
35039
+ runtime.state[key] = created;
34895
35040
  return created;
34896
35041
  }
34897
- async function runReview(args) {
34898
- const outcome = await spawnReview(args).catch((error) => errorDraft({
34899
- candidate: args.candidate,
34900
- tier: args.tier,
34901
- reasons: args.reasons,
34902
- reviewedHead: args.detail.headRefOid,
34903
- error: firstLine$1(errorMessage(error)) || "review crashed"
34904
- }));
34905
- const entry = entryFor(args.candidate.key);
34906
- entry.inFlight = false;
34907
- hasSlotFreedSinceSlotCount = true;
34908
- progressByKey.delete(args.candidate.key);
34909
- reviewCancellersByKey.delete(args.candidate.key);
34910
- if (notMineWhileReviewingKeys.delete(args.candidate.key)) {
34911
- await settleNotMineReview(entry, args, outcome);
34912
- return;
34913
- }
34914
- if ("kind" in outcome) {
34915
- if (outcome.resumable) entry.resumable = outcome.resumable;
34916
- await persist();
34917
- emitStatus();
34918
- return;
34919
- }
34920
- const draft = outcome;
34921
- const wasRequeuedAtReviewedHead = entry.requeuedHead === draft.reviewedHead;
34922
- entry.resumable = null;
34923
- if (draft.status !== "error") {
34924
- delete entry.requeuedHead;
34925
- delete entry.discardedReviewHead;
34926
- }
34927
- entry.reviewAttempts = reviewAttemptsAfter(entry, draft.reviewedHead);
34928
- entry.draft = {
34929
- ...draft,
34930
- ...args.candidate.prCreatedAt ? { prCreatedAt: args.candidate.prCreatedAt } : {},
34931
- ...args.priorReview ? { priorReviewedHead: args.priorReview.head } : {},
34932
- ...wasRequeuedAtReviewedHead ? { requeuedHead: draft.reviewedHead } : {}
34933
- };
34934
- entry.reviewedHead = draft.reviewedHead;
34935
- entry.updatedAt = now();
34936
- entry.reviewedAt = entry.updatedAt;
34937
- entry.draft.reviewedAt = entry.reviewedAt;
34938
- await persist();
34939
- emitStatus();
34940
- if (draft.status === "ready") telemetry?.capture("team_review_drafted", { inline_comment_count: draft.comments.length });
34941
- if (waitingForSlot.length > 0 && !loop.isStopped()) loop.tick();
34942
- }
34943
- async function settleNotMineReview(entry, args, outcome) {
34944
- if ("kind" in outcome && outcome.resumable) await discardResumable(outcome.resumable);
34945
- entry.resumable = null;
34946
- entry.draft = !("kind" in outcome) && outcome.status !== "error" ? {
34947
- ...outcome,
34948
- status: "discarded"
34949
- } : notMineDraft(args.candidate, args.detail.headRefOid);
34950
- entry.reviewedHead = entry.draft.reviewedHead;
34951
- await settleNotMine(args.candidate.key, entry);
34952
- if (waitingForSlot.length > 0 && !loop.isStopped()) loop.tick();
34953
- }
34954
35042
  function headsToReview(candidates) {
34955
35043
  const queue = [];
34956
35044
  let isDirty = false;
34957
35045
  const prs = store.getSnapshot().prs;
34958
35046
  for (const candidate of candidates) {
34959
- let entry = state[candidate.key];
35047
+ let entry = runtime.state[candidate.key];
34960
35048
  if (entry?.inFlight) continue;
34961
35049
  const pr = prs[comparablePrKey(candidate)];
34962
35050
  if (!pr) continue;
34963
35051
  const snapshot = reviewSnapshotFromGithubPr(pr);
34964
35052
  const head = snapshot.head;
34965
- const githubReviews = githubReviewsFrom(snapshot.reviews, self ?? "");
35053
+ const githubReviews = githubReviewsFrom(snapshot.reviews, runtime.self ?? "");
34966
35054
  const reviewDecision = snapshot.reviewDecision ?? null;
34967
35055
  candidate.reviewDecision = reviewDecision;
34968
35056
  candidate.isDraft = snapshot.isDraft;
@@ -35033,23 +35121,33 @@ function createTeamReviewPoller(deps) {
35033
35121
  isDirty
35034
35122
  };
35035
35123
  }
35124
+ return {
35125
+ entryFor,
35126
+ headsToReview
35127
+ };
35128
+ }
35129
+ //#endregion
35130
+ //#region server/github/team-review-poller/team-review-answered-threads.ts
35131
+ function createTeamReviewAnsweredThreads(context, statusReporter) {
35132
+ const { deps, github, store, now, runtime, loop, persist } = context;
35133
+ const { emitStatus } = statusReporter;
35036
35134
  async function handleAnsweredThreads(candidates) {
35037
35135
  if (!github.resolveReviewThread) return false;
35038
35136
  const eligible = candidates.filter(({ key }) => {
35039
- const entry = state[key];
35137
+ const entry = runtime.state[key];
35040
35138
  return entry?.githubReviews?.some((review) => review.isViewer) || entry?.draft?.status === "posted";
35041
35139
  });
35042
35140
  if (eligible.length === 0) return false;
35043
35141
  const fetchedRead = await store.requestTeamReviewThreads(eligible, "no-wait");
35044
35142
  if (fetchedRead.isRateLimited) {
35045
- tickRateLimitWaitMs = fetchedRead.waitMs;
35143
+ runtime.tickRateLimitWaitMs = fetchedRead.waitMs;
35046
35144
  return false;
35047
35145
  }
35048
35146
  const fetched = fetchedRead.value;
35049
35147
  let isDirty = false;
35050
35148
  for (const candidate of eligible) {
35051
35149
  if (loop.isStopped()) break;
35052
- const entry = state[candidate.key];
35150
+ const entry = runtime.state[candidate.key];
35053
35151
  const nodes = fetched.get(candidate.key);
35054
35152
  const head = entry?.liveHead;
35055
35153
  if (!entry || !nodes || !head) continue;
@@ -35092,7 +35190,7 @@ function createTeamReviewPoller(deps) {
35092
35190
  }
35093
35191
  };
35094
35192
  if (comparisonRead.isRateLimited) {
35095
- tickRateLimitWaitMs = comparisonRead.waitMs;
35193
+ runtime.tickRateLimitWaitMs = comparisonRead.waitMs;
35096
35194
  return isDirty;
35097
35195
  }
35098
35196
  const comparisonOutcome = comparisonRead.value;
@@ -35120,7 +35218,7 @@ function createTeamReviewPoller(deps) {
35120
35218
  }
35121
35219
  emitStatus();
35122
35220
  const judgement = parseThreadJudgeResult(await deps.judgeThread(buildThreadJudgeRequest(node, head, evidence.patch)).catch(() => null));
35123
- if (judgement && state[candidate.key] === entry && entry.liveHead === head && entry.threads?.includes(thread)) {
35221
+ if (judgement && runtime.state[candidate.key] === entry && entry.liveHead === head && entry.threads?.includes(thread)) {
35124
35222
  thread.judgement = {
35125
35223
  ...judgement,
35126
35224
  head,
@@ -35156,37 +35254,74 @@ function createTeamReviewPoller(deps) {
35156
35254
  }
35157
35255
  return false;
35158
35256
  }
35159
- function closedEntryKeys() {
35160
- const prs = store.getSnapshot().prs;
35161
- return new Set(Object.keys(state).filter((key) => {
35162
- const pr = prs[key.toLowerCase()];
35163
- return !state[key]?.inFlight && pr !== void 0 && pr.state !== "OPEN";
35164
- }));
35165
- }
35166
- function watchDeparted(candidateKeys) {
35167
- const departedKeys = Object.keys(state).filter((key) => !candidateKeys.has(key) && !state[key]?.inFlight);
35168
- store.setWatchedKeys("team-review-departed", departedKeys.map((key) => key.toLowerCase()));
35169
- }
35170
- async function pruneDeparted(candidateKeys, isComplete) {
35171
- let isDirty = false;
35172
- watchDeparted(candidateKeys);
35173
- const closedKeys = closedEntryKeys();
35174
- for (const [key, entry] of Object.entries(state)) {
35175
- const isClosed = closedKeys.has(key);
35176
- if (candidateKeys.has(key) || !isComplete && !isClosed) continue;
35177
- if (entry.resumable) {
35178
- await discardResumable(entry.resumable);
35179
- entry.resumable = null;
35180
- isDirty = true;
35181
- }
35182
- if (!shouldPruneEntry$1(entry, false, now(), isClosed)) continue;
35183
- delete state[key];
35184
- isDirty = true;
35257
+ return { handleAnsweredThreads };
35258
+ }
35259
+ //#endregion
35260
+ //#region server/github/team-review-poller/team-review-runs.ts
35261
+ function createTeamReviewRuns(context, statusReporter, headPlanning, candidateSearch) {
35262
+ const { store, spawnReview, discardResumable, log, telemetry, now, maxConcurrentReviews, runtime, progressByKey, reviewCancellersByKey, notMineWhileReviewingKeys, loop, persist } = context;
35263
+ const { emitStatus, inFlightKeys, progressReporter } = statusReporter;
35264
+ const { entryFor } = headPlanning;
35265
+ const { watchAskedFor } = candidateSearch;
35266
+ async function runReview(args) {
35267
+ const outcome = await spawnReview(args).catch((error) => errorDraft({
35268
+ candidate: args.candidate,
35269
+ tier: args.tier,
35270
+ reasons: args.reasons,
35271
+ reviewedHead: args.detail.headRefOid,
35272
+ error: firstLine$1(errorMessage(error)) || "review crashed"
35273
+ }));
35274
+ const entry = entryFor(args.candidate.key);
35275
+ entry.inFlight = false;
35276
+ runtime.hasSlotFreedSinceSlotCount = true;
35277
+ progressByKey.delete(args.candidate.key);
35278
+ reviewCancellersByKey.delete(args.candidate.key);
35279
+ if (notMineWhileReviewingKeys.delete(args.candidate.key)) {
35280
+ await settleNotMineReview(entry, args, outcome);
35281
+ return;
35185
35282
  }
35186
- return isDirty;
35283
+ if ("kind" in outcome) {
35284
+ if (outcome.resumable) entry.resumable = outcome.resumable;
35285
+ await persist();
35286
+ emitStatus();
35287
+ return;
35288
+ }
35289
+ const draft = outcome;
35290
+ const wasRequeuedAtReviewedHead = entry.requeuedHead === draft.reviewedHead;
35291
+ entry.resumable = null;
35292
+ if (draft.status !== "error") {
35293
+ delete entry.requeuedHead;
35294
+ delete entry.discardedReviewHead;
35295
+ }
35296
+ entry.reviewAttempts = reviewAttemptsAfter(entry, draft.reviewedHead);
35297
+ entry.draft = {
35298
+ ...draft,
35299
+ ...args.candidate.prCreatedAt ? { prCreatedAt: args.candidate.prCreatedAt } : {},
35300
+ ...args.priorReview ? { priorReviewedHead: args.priorReview.head } : {},
35301
+ ...wasRequeuedAtReviewedHead ? { requeuedHead: draft.reviewedHead } : {}
35302
+ };
35303
+ entry.reviewedHead = draft.reviewedHead;
35304
+ entry.updatedAt = now();
35305
+ entry.reviewedAt = entry.updatedAt;
35306
+ entry.draft.reviewedAt = entry.reviewedAt;
35307
+ await persist();
35308
+ emitStatus();
35309
+ if (draft.status === "ready") telemetry?.capture("team_review_drafted", { inline_comment_count: draft.comments.length });
35310
+ if (runtime.waitingForSlot.length > 0 && !loop.isStopped()) loop.tick();
35311
+ }
35312
+ async function settleNotMineReview(entry, args, outcome) {
35313
+ if ("kind" in outcome && outcome.resumable) await discardResumable(outcome.resumable);
35314
+ entry.resumable = null;
35315
+ entry.draft = !("kind" in outcome) && outcome.status !== "error" ? {
35316
+ ...outcome,
35317
+ status: "discarded"
35318
+ } : notMineDraft(args.candidate, args.detail.headRefOid);
35319
+ entry.reviewedHead = entry.draft.reviewedHead;
35320
+ await settleNotMine(args.candidate.key, entry);
35321
+ if (runtime.waitingForSlot.length > 0 && !loop.isStopped()) loop.tick();
35187
35322
  }
35188
35323
  function leaveSlotQueue(key) {
35189
- waitingForSlot = waitingForSlot.filter((queued) => queued.key !== key);
35324
+ runtime.waitingForSlot = runtime.waitingForSlot.filter((queued) => queued.key !== key);
35190
35325
  }
35191
35326
  async function readCandidateDetail(candidate) {
35192
35327
  const snapshotHead = store.getSnapshot().prs[comparablePrKey(candidate)]?.headRefOid;
@@ -35202,19 +35337,19 @@ function createTeamReviewPoller(deps) {
35202
35337
  return store.requestPrView(candidate.repo, candidate.number, headRead.value, "no-wait");
35203
35338
  }
35204
35339
  async function startReviews(queue) {
35205
- hasSlotFreedSinceSlotCount = false;
35340
+ runtime.hasSlotFreedSinceSlotCount = false;
35206
35341
  let freeSlots = maxConcurrentReviews - inFlightKeys().length;
35207
35342
  let isDirty = false;
35208
- waitingForSlot = queue.filter((queued) => state[queued.key]?.draft?.status !== "discarded");
35343
+ runtime.waitingForSlot = queue.filter((queued) => runtime.state[queued.key]?.draft?.status !== "discarded");
35209
35344
  for (const candidate of queue) {
35210
35345
  if (loop.isStopped()) {
35211
- waitingForSlot = [];
35346
+ runtime.waitingForSlot = [];
35212
35347
  break;
35213
35348
  }
35214
35349
  if (freeSlots <= 0) break;
35215
35350
  const detailRead = await readCandidateDetail(candidate);
35216
35351
  if (detailRead.isRateLimited) {
35217
- tickRateLimitWaitMs = detailRead.waitMs;
35352
+ runtime.tickRateLimitWaitMs = detailRead.waitMs;
35218
35353
  break;
35219
35354
  }
35220
35355
  const detail = detailRead.value;
@@ -35270,223 +35405,36 @@ function createTeamReviewPoller(deps) {
35270
35405
  }
35271
35406
  return isDirty;
35272
35407
  }
35273
- async function collectCandidates() {
35274
- const firstTeam = teams[0];
35275
- if (!firstTeam) {
35276
- unregisterWatches();
35277
- return null;
35278
- }
35279
- if (teamProfile === null) {
35280
- const profileRead = await store.requestTeamProfile(firstTeam.org, firstTeam.slug, "no-wait");
35281
- if (profileRead.isRateLimited) {
35282
- tickRateLimitWaitMs = profileRead.waitMs;
35283
- return null;
35284
- }
35285
- teamProfile = profileRead.value;
35286
- }
35287
- if (self === null) {
35288
- const viewerRead = await store.requestViewer("no-wait");
35289
- if (viewerRead.isRateLimited) {
35290
- tickRateLimitWaitMs = viewerRead.waitMs;
35291
- return null;
35292
- }
35293
- self = viewerRead.value;
35294
- }
35295
- const viewer = self;
35296
- if (viewer === null) return null;
35297
- const memberLists = [];
35298
- for (const team of teams) {
35299
- const membersRead = await store.requestTeamMembers(team.org, team.slug, "no-wait");
35300
- if (membersRead.isRateLimited) {
35301
- tickRateLimitWaitMs = membersRead.waitMs;
35302
- return null;
35303
- }
35304
- memberLists.push(membersRead.value);
35305
- }
35306
- const isMembershipComplete = memberLists.every((members) => members !== null);
35307
- const fetchedMemberLists = memberLists.map((members) => members ?? []);
35308
- if (fetchedMemberLists.every((members) => members.length === 0)) {
35309
- if (isMembershipComplete) unregisterWatches();
35310
- return null;
35311
- }
35312
- if (loop.isStopped()) return null;
35313
- registerWatches(orgSearchPlans(org, teams, fetchedMemberLists, viewer));
35314
- const collected = candidatesFromSnapshot(viewer);
35315
- teamCandidateKeys = collected.teamCandidateKeys;
35316
- return {
35317
- candidates: collected.candidates,
35318
- isComplete: isMembershipComplete && collected.isComplete
35319
- };
35320
- }
35321
- function registerWatches(searchPlans) {
35322
- const nextWatches = /* @__PURE__ */ new Map();
35323
- for (const plan of searchPlans) {
35324
- nextWatches.set(`team-review-direct:${plan.org.toLowerCase()}`, {
35325
- qualifiers: `is:open draft:false org:${plan.org} user-review-requested:@me`,
35326
- source: "direct"
35327
- });
35328
- for (let index = 0; index < plan.authors.length; index += 5) {
35329
- const authors = plan.authors.slice(index, index + 5).map((author) => `author:${author}`).join(" ");
35330
- nextWatches.set(`team-review-authored:${plan.org.toLowerCase()}:${index / 5}`, {
35331
- qualifiers: `is:open draft:false org:${plan.org} ${authors}`,
35332
- source: "authored"
35333
- });
35334
- }
35335
- }
35336
- for (const team of teams) nextWatches.set(`team-review-team:${team.org.toLowerCase()}/${team.slug.toLowerCase()}`, {
35337
- qualifiers: `is:open draft:false org:${team.org} team-review-requested:${team.org}/${team.slug}`,
35338
- source: "team"
35339
- });
35340
- for (const name of watches.keys()) if (!nextWatches.has(name)) store.unregisterWatch(name);
35341
- for (const [name, watch] of nextWatches) if (watches.get(name)?.qualifiers !== watch.qualifiers) store.registerWatch({
35342
- name,
35343
- qualifiers: watch.qualifiers,
35344
- needsDetail: true
35345
- });
35346
- watches.clear();
35347
- for (const [name, watch] of nextWatches) watches.set(name, watch);
35348
- }
35349
- function askedForKeys() {
35350
- return Object.keys(state).filter((key) => state[key]?.requestedAt !== void 0);
35351
- }
35352
- function isTeamCandidate(key) {
35353
- return teamCandidateKeys.has(key.toLowerCase());
35354
- }
35355
- function askedForSlotsInUse() {
35356
- return askedForKeys().filter((key) => state[key]?.draft?.status !== "posted" && !isTeamCandidate(key)).length;
35357
- }
35358
- function watchAskedFor() {
35359
- store.setWatchedKeys(ASKED_FOR_WATCH_OWNER, askedForKeys());
35360
- }
35361
- function candidatesFromSnapshot(viewer) {
35362
- const snapshot = store.getSnapshot();
35363
- let isAskedForComplete = true;
35364
- const askedFor = askedForKeys().flatMap((key) => {
35365
- const pr = snapshot.prs[key.toLowerCase()];
35366
- if (pr) return [pr];
35367
- const requestedAt = state[key]?.requestedAt ?? 0;
35368
- if (now() - requestedAt < 36e5) isAskedForComplete = false;
35369
- return [];
35370
- });
35371
- const prsBySource = {
35372
- direct: [],
35373
- team: [],
35374
- authored: []
35375
- };
35376
- let isComplete = true;
35377
- for (const [name, { source }] of watches) {
35378
- const watch = snapshot.watches[name];
35379
- if (!watch?.isLoaded || !watch.isComplete) isComplete = false;
35380
- for (const key of watch?.keys ?? []) {
35381
- const pr = snapshot.prs[key];
35382
- if (!pr) {
35383
- isComplete = false;
35384
- continue;
35385
- }
35386
- prsBySource[source].push(pr);
35387
- }
35408
+ async function settleNotMine(key, entry) {
35409
+ delete entry.requeuedHead;
35410
+ delete entry.requestedAt;
35411
+ watchAskedFor();
35412
+ entry.updatedAt = now();
35413
+ runtime.waitingForSlot = runtime.waitingForSlot.filter((queued) => queued.key !== key);
35414
+ const abandonedResumable = entry.resumable;
35415
+ if (abandonedResumable) {
35416
+ entry.resumable = null;
35417
+ await discardResumable(abandonedResumable);
35388
35418
  }
35389
- return {
35390
- ...selectCandidates(prsBySource.direct, prsBySource.team, prsBySource.authored, {
35391
- self: viewer,
35392
- nowMs: now(),
35393
- skipIdleAfterMs,
35394
- askedFor
35395
- }),
35396
- isComplete: isComplete && isAskedForComplete
35397
- };
35398
- }
35399
- function rebuild() {
35400
- if (!hasLoadedState || loop.isStopped() || self === null) return;
35401
- const collected = candidatesFromSnapshot(self);
35402
- teamCandidateKeys = collected.teamCandidateKeys;
35403
- const { candidates } = collected;
35404
- const planned = headsToReview(candidates);
35405
- if (planned.isDirty) loop.track(persist());
35419
+ await persist();
35406
35420
  emitStatus();
35407
- if (closedEntryKeys().size > 0) {
35408
- loop.tickSoon();
35409
- return;
35410
- }
35411
- if (planned.queue.length === 0 || !canStartReview()) return;
35412
- const queueSignature = queuedHeadsSignature(planned.queue);
35413
- if (queueSignature === lastRebuildQueueSignature) return;
35414
- lastRebuildQueueSignature = queueSignature;
35415
- loop.tickSoon();
35416
- }
35417
- function canStartReview() {
35418
- return inFlightKeys().length < maxConcurrentReviews;
35419
- }
35420
- function queuedHeadsSignature(queue) {
35421
- const prs = store.getSnapshot().prs;
35422
- return JSON.stringify(queue.map((candidate) => [candidate.key, prs[comparablePrKey(candidate)]?.headRefOid ?? null]));
35423
- }
35424
- async function rateLimitedOutcome() {
35425
- const rateLimitWaitMs = await store.rateLimitWaitMs(now(), TEAM_REVIEW_RATE_LIMIT_RESOURCES) ?? secondaryRateLimitWaitMs(pollingError);
35426
- return rateLimitWaitMs === null ? {
35427
- failed: true,
35428
- error: pollingError ?? void 0
35429
- } : {
35430
- failed: true,
35431
- retryAfterMs: rateLimitWaitMs,
35432
- error: pollingError ?? void 0
35433
- };
35434
- }
35435
- async function runTick() {
35436
- pollingError = null;
35437
- tickRateLimitWaitMs = null;
35438
- const collected = await collectCandidates().catch((error) => {
35439
- pollingError = errorMessage(error);
35440
- log.warn(`[${TEAM_REVIEW_LANE_ID}] candidate search failed: ${pollingError}`);
35441
- return null;
35442
- });
35443
- if (tickRateLimitWaitMs !== null) {
35444
- pollingError = "GitHub rate limit asks to wait.";
35445
- return {
35446
- failed: true,
35447
- retryAfterMs: tickRateLimitWaitMs,
35448
- error: pollingError
35449
- };
35450
- }
35451
- if (collected === null) {
35452
- pollingError ??= "Could not look up your GitHub account or team members.";
35453
- return rateLimitedOutcome();
35454
- }
35455
- const storeError = store.getSnapshot().freshness.error;
35456
- if (storeError) {
35457
- pollingError = storeError;
35458
- return rateLimitedOutcome();
35459
- }
35460
- const { candidates, isComplete } = collected;
35461
- const rateLimitWaitMs = isComplete ? null : await store.rateLimitWaitMs(now(), TEAM_REVIEW_RATE_LIMIT_RESOURCES);
35462
- if (rateLimitWaitMs !== null) {
35463
- pollingError = "GitHub rate limit asks to wait.";
35464
- return {
35465
- failed: true,
35466
- retryAfterMs: rateLimitWaitMs,
35467
- error: pollingError
35468
- };
35469
- }
35470
- const isPruned = await pruneDeparted(new Set(candidates.map((candidate) => candidate.key)), isComplete);
35471
- if (isPruned) watchAskedFor();
35472
- const planned = headsToReview(candidates);
35473
- const isStarted = await startReviews(planned.queue);
35474
- const areThreadsChanged = tickRateLimitWaitMs === null ? await handleAnsweredThreads(candidates) : false;
35475
- if (isPruned || planned.isDirty || areThreadsChanged || isStarted) await persist();
35476
- if (tickRateLimitWaitMs !== null) {
35477
- pollingError = "GitHub rate limit asks to wait.";
35478
- return {
35479
- failed: true,
35480
- retryAfterMs: tickRateLimitWaitMs,
35481
- error: pollingError
35482
- };
35483
- }
35484
- if (hasSlotFreedSinceSlotCount && waitingForSlot.length > 0 && !loop.isStopped()) setTimeoutFn(() => {
35485
- loop.tick();
35486
- }, 0);
35421
+ return { ok: true };
35487
35422
  }
35423
+ return {
35424
+ startReviews,
35425
+ settleNotMine
35426
+ };
35427
+ }
35428
+ //#endregion
35429
+ //#region server/github/team-review-poller/team-review-operator-actions.ts
35430
+ function createTeamReviewOperatorActions(context, statusReporter, headPlanning, candidateSearch, reviewRuns) {
35431
+ const { store, now, runtime, reviewCancellersByKey, notMineWhileReviewingKeys, loop, persist } = context;
35432
+ const { emitStatus } = statusReporter;
35433
+ const { entryFor } = headPlanning;
35434
+ const { isTeamCandidate, askedForSlotsInUse, watchAskedFor } = candidateSearch;
35435
+ const { settleNotMine } = reviewRuns;
35488
35436
  function getDraft(key) {
35489
- const entry = state[key];
35437
+ const entry = runtime.state[key];
35490
35438
  if (!entry?.draft) return null;
35491
35439
  return {
35492
35440
  ...entry.draft,
@@ -35496,7 +35444,7 @@ function createTeamReviewPoller(deps) {
35496
35444
  };
35497
35445
  }
35498
35446
  async function updateDraft(key, expected, patch) {
35499
- const entry = state[key];
35447
+ const entry = runtime.state[key];
35500
35448
  if (!entry?.draft) return null;
35501
35449
  if (entry.draft.reviewedHead !== expected.reviewedHead || entry.draft.status !== expected.status) return null;
35502
35450
  const postedAt = patch.status === "posted" ? { postedAt: now() } : {};
@@ -35516,7 +35464,7 @@ function createTeamReviewPoller(deps) {
35516
35464
  return parsed.data;
35517
35465
  }
35518
35466
  async function updateThread(key, threadId, patch) {
35519
- const entry = state[key];
35467
+ const entry = runtime.state[key];
35520
35468
  const thread = entry?.threads?.find((thread) => thread.id === threadId);
35521
35469
  if (!entry || !thread) return false;
35522
35470
  Object.assign(thread, patch);
@@ -35527,7 +35475,7 @@ function createTeamReviewPoller(deps) {
35527
35475
  return true;
35528
35476
  }
35529
35477
  async function requeue(key, head) {
35530
- const entry = state[key];
35478
+ const entry = runtime.state[key];
35531
35479
  if (!entry?.draft || entry.inFlight || entry.draft.reviewedHead !== head) return false;
35532
35480
  if (!REQUEUEABLE_STATUSES.has(entry.draft.status)) return false;
35533
35481
  entry.reviewAttempts = 0;
@@ -35554,7 +35502,7 @@ function createTeamReviewPoller(deps) {
35554
35502
  return { ok: true };
35555
35503
  }
35556
35504
  async function markNotMine(key) {
35557
- const entry = state[key];
35505
+ const entry = runtime.state[key];
35558
35506
  if (entry?.inFlight) return cancelReviewAsNotMine(key);
35559
35507
  if (entry?.draft?.status === "posted") return {
35560
35508
  ok: false,
@@ -35567,7 +35515,7 @@ function createTeamReviewPoller(deps) {
35567
35515
  };
35568
35516
  return settleNotMine(key, entry);
35569
35517
  }
35570
- const candidate = waitingForSlot.find((queued) => queued.key === key) ?? entry?.draft ?? void 0;
35518
+ const candidate = runtime.waitingForSlot.find((queued) => queued.key === key) ?? entry?.draft ?? void 0;
35571
35519
  if (!candidate) return {
35572
35520
  ok: false,
35573
35521
  error: "That pull request is no longer in the review queue"
@@ -35586,27 +35534,12 @@ function createTeamReviewPoller(deps) {
35586
35534
  ok: false,
35587
35535
  error: "Could not read the pull request head from GitHub"
35588
35536
  };
35589
- if (state[key]?.inFlight) return cancelReviewAsNotMine(key);
35537
+ if (runtime.state[key]?.inFlight) return cancelReviewAsNotMine(key);
35590
35538
  const notMineEntry = entryFor(key);
35591
35539
  notMineEntry.draft = notMineDraft(candidate, head);
35592
35540
  notMineEntry.reviewedHead = head;
35593
35541
  return settleNotMine(key, notMineEntry);
35594
35542
  }
35595
- async function settleNotMine(key, entry) {
35596
- delete entry.requeuedHead;
35597
- delete entry.requestedAt;
35598
- watchAskedFor();
35599
- entry.updatedAt = now();
35600
- waitingForSlot = waitingForSlot.filter((queued) => queued.key !== key);
35601
- const abandonedResumable = entry.resumable;
35602
- if (abandonedResumable) {
35603
- entry.resumable = null;
35604
- await discardResumable(abandonedResumable);
35605
- }
35606
- await persist();
35607
- emitStatus();
35608
- return { ok: true };
35609
- }
35610
35543
  async function markAskedFor(key, entry) {
35611
35544
  if (!isTeamCandidate(key)) entry.requestedAt ??= now();
35612
35545
  entry.updatedAt = now();
@@ -35615,111 +35548,290 @@ function createTeamReviewPoller(deps) {
35615
35548
  emitStatus();
35616
35549
  loop.tickSoon();
35617
35550
  }
35618
- async function requestKnownReview(key, entry) {
35619
- if (entry.inFlight) return {
35620
- ok: true,
35621
- key,
35622
- status: "running"
35551
+ async function requestKnownReview(key, entry) {
35552
+ if (entry.inFlight) return {
35553
+ ok: true,
35554
+ key,
35555
+ status: "running"
35556
+ };
35557
+ if (entry.draft && !isThreadPlaceholderDraft(entry.draft)) {
35558
+ if (!await requeue(key, entry.draft.reviewedHead)) return {
35559
+ ok: false,
35560
+ error: REQUEUE_REFUSAL
35561
+ };
35562
+ await markAskedFor(key, entry);
35563
+ return {
35564
+ ok: true,
35565
+ key,
35566
+ status: "queued"
35567
+ };
35568
+ }
35569
+ if (entry.reviewedHead !== null) {
35570
+ entry.reviewedHead = null;
35571
+ entry.reviewAttempts = 0;
35572
+ if (entry.liveHead) entry.requeuedHead = entry.liveHead;
35573
+ }
35574
+ await markAskedFor(key, entry);
35575
+ return {
35576
+ ok: true,
35577
+ key,
35578
+ status: "queued"
35579
+ };
35580
+ }
35581
+ async function requestReview(reference) {
35582
+ if (loop.isStopped() || !runtime.hasLoadedState) return {
35583
+ ok: false,
35584
+ error: "Team review is not running"
35585
+ };
35586
+ const findKnownKey = () => Object.keys(runtime.state).find((key) => key.toLowerCase() === comparablePrKey(reference));
35587
+ const knownKey = findKnownKey();
35588
+ const knownEntry = knownKey === void 0 ? void 0 : runtime.state[knownKey];
35589
+ if (knownKey !== void 0 && knownEntry) return requestKnownReview(knownKey, knownEntry);
35590
+ if (!isTeamCandidate(comparablePrKey(reference)) && askedForSlotsInUse() >= 20) return {
35591
+ ok: false,
35592
+ error: `at most 20 pull requests outside your teams can wait for a review at once, and one frees when its review is posted or the operator marks it Not mine in the Reviews tab`
35593
+ };
35594
+ const label = prKey(reference.repo, reference.number);
35595
+ const headRead = await store.requestPrHead(reference.repo, reference.number, "no-wait");
35596
+ if (headRead.isRateLimited) return {
35597
+ ok: false,
35598
+ error: githubStoreRateLimitedError(headRead.waitMs)
35599
+ };
35600
+ if (headRead.value === null) return {
35601
+ ok: false,
35602
+ error: `could not read ${label} from GitHub`
35603
+ };
35604
+ const detailRead = await store.requestPrView(reference.repo, reference.number, headRead.value, "no-wait");
35605
+ if (detailRead.isRateLimited) return {
35606
+ ok: false,
35607
+ error: githubStoreRateLimitedError(detailRead.waitMs)
35608
+ };
35609
+ const detail = detailRead.value;
35610
+ if (!detail) return {
35611
+ ok: false,
35612
+ error: `could not read ${label} from GitHub`
35613
+ };
35614
+ const refusal = askedForRefusal(detail, runtime.self);
35615
+ if (refusal) return {
35616
+ ok: false,
35617
+ error: `${label} cannot be reviewed: ${refusal}`
35618
+ };
35619
+ const raceKey = findKnownKey();
35620
+ const raceEntry = raceKey === void 0 ? void 0 : runtime.state[raceKey];
35621
+ if (raceKey !== void 0 && raceEntry) return requestKnownReview(raceKey, raceEntry);
35622
+ const key = pullRequestKeyFromReference(detail.url) ?? label;
35623
+ const entry = entryFor(key);
35624
+ entry.liveHead = detail.headRefOid;
35625
+ entry.requeuedHead = detail.headRefOid;
35626
+ await markAskedFor(key, entry);
35627
+ return {
35628
+ ok: true,
35629
+ key,
35630
+ status: "queued"
35631
+ };
35632
+ }
35633
+ return {
35634
+ getDraft,
35635
+ updateDraft,
35636
+ updateThread,
35637
+ requeue,
35638
+ requestReview,
35639
+ markNotMine
35640
+ };
35641
+ }
35642
+ //#endregion
35643
+ //#region server/github/team-review-poller.ts
35644
+ function createTeamReviewPoller(deps) {
35645
+ const { org, teams, github, store, spawnReview, discardResumable = async () => {}, readState = async () => ({}), writeState = async () => {}, beforeStart = async () => {}, setIntervalFn = DEFAULT_TIMER_FNS.setIntervalFn, clearIntervalFn = DEFAULT_TIMER_FNS.clearIntervalFn, setTimeoutFn = DEFAULT_TIMER_FNS.setTimeoutFn, clearTimeoutFn = DEFAULT_TIMER_FNS.clearTimeoutFn, log = console, telemetry = null, onTickComplete = () => {}, now = () => Date.now() } = deps;
35646
+ const maxConcurrentReviews = deps.maxConcurrentReviews ?? 2;
35647
+ const reReviewAfterMs = deps.reReviewAfterMs ?? 864e5;
35648
+ const skipIdleAfterMs = deps.skipIdleAfterMs ?? 12096e5;
35649
+ const runtime = {
35650
+ state: {},
35651
+ self: null,
35652
+ teamProfile: null,
35653
+ waitingForSlot: [],
35654
+ pollingError: null,
35655
+ tickRateLimitWaitMs: null,
35656
+ teamCandidateKeys: /* @__PURE__ */ new Set(),
35657
+ hasLoadedState: false,
35658
+ hasSlotFreedSinceSlotCount: false
35659
+ };
35660
+ const progressByKey = /* @__PURE__ */ new Map();
35661
+ const reviewCancellersByKey = /* @__PURE__ */ new Map();
35662
+ const notMineWhileReviewingKeys = /* @__PURE__ */ new Set();
35663
+ const watches = /* @__PURE__ */ new Map();
35664
+ let lastRebuildQueueSignature = null;
35665
+ const loop = createTickLoop({
35666
+ tag: TEAM_REVIEW_LANE_ID,
35667
+ intervalMs: (deps.intervalMinutes ?? 15) * 6e4,
35668
+ tick: async () => {
35669
+ try {
35670
+ return await runTick();
35671
+ } catch (error) {
35672
+ runtime.pollingError = errorMessage(error);
35673
+ log.warn(`[${TEAM_REVIEW_LANE_ID}] poll failed: ${runtime.pollingError}`);
35674
+ return rateLimitedOutcome();
35675
+ }
35676
+ },
35677
+ quickRetries: true,
35678
+ now,
35679
+ setTimeoutFn,
35680
+ clearTimeoutFn,
35681
+ onScheduleChange: () => {
35682
+ emitStatus();
35683
+ },
35684
+ rateLimitWaitMs: () => store.rateLimitWaitMs(now(), TEAM_REVIEW_RATE_LIMIT_RESOURCES),
35685
+ writeState: () => writeState(runtime.state),
35686
+ setIntervalFn,
35687
+ clearIntervalFn,
35688
+ clock: storeReadingLaneClock(deps.clock),
35689
+ firstTickDelayMs: deps.firstTickDelayMs,
35690
+ backoffMaxMs: GITHUB_RATE_LIMIT_WINDOW_MS,
35691
+ log
35692
+ });
35693
+ const persist = () => loop.persist();
35694
+ const context = {
35695
+ deps,
35696
+ org,
35697
+ teams,
35698
+ github,
35699
+ store,
35700
+ spawnReview,
35701
+ discardResumable,
35702
+ log,
35703
+ telemetry,
35704
+ onTickComplete,
35705
+ now,
35706
+ setTimeoutFn,
35707
+ clearTimeoutFn,
35708
+ maxConcurrentReviews,
35709
+ reReviewAfterMs,
35710
+ skipIdleAfterMs,
35711
+ runtime,
35712
+ progressByKey,
35713
+ reviewCancellersByKey,
35714
+ notMineWhileReviewingKeys,
35715
+ watches,
35716
+ loop,
35717
+ persist
35718
+ };
35719
+ const statusReporter = createTeamReviewStatusReporter(context);
35720
+ const candidateSearch = createTeamReviewCandidateSearch(context);
35721
+ const headPlanning = createTeamReviewHeadPlanning(context);
35722
+ const { handleAnsweredThreads } = createTeamReviewAnsweredThreads(context, statusReporter);
35723
+ const reviewRuns = createTeamReviewRuns(context, statusReporter, headPlanning, candidateSearch);
35724
+ const { getDraft, updateDraft, updateThread, requeue, requestReview, markNotMine } = createTeamReviewOperatorActions(context, statusReporter, headPlanning, candidateSearch, reviewRuns);
35725
+ const { inFlightKeys, cancelPendingProgressEmit, emitStatus } = statusReporter;
35726
+ const { closedEntryKeys, pruneDeparted, collectCandidates, watchAskedFor, candidatesFromSnapshot, unregisterWatches } = candidateSearch;
35727
+ const { headsToReview } = headPlanning;
35728
+ const { startReviews } = reviewRuns;
35729
+ function rebuild() {
35730
+ if (!runtime.hasLoadedState || loop.isStopped() || runtime.self === null) return;
35731
+ const collected = candidatesFromSnapshot(runtime.self);
35732
+ runtime.teamCandidateKeys = collected.teamCandidateKeys;
35733
+ const { candidates } = collected;
35734
+ const planned = headsToReview(candidates);
35735
+ if (planned.isDirty) loop.track(persist());
35736
+ emitStatus();
35737
+ if (closedEntryKeys().size > 0) {
35738
+ loop.tickSoon();
35739
+ return;
35740
+ }
35741
+ if (planned.queue.length === 0 || !canStartReview()) return;
35742
+ const queueSignature = queuedHeadsSignature(planned.queue);
35743
+ if (queueSignature === lastRebuildQueueSignature) return;
35744
+ lastRebuildQueueSignature = queueSignature;
35745
+ loop.tickSoon();
35746
+ }
35747
+ function canStartReview() {
35748
+ return inFlightKeys().length < maxConcurrentReviews;
35749
+ }
35750
+ function queuedHeadsSignature(queue) {
35751
+ const prs = store.getSnapshot().prs;
35752
+ return JSON.stringify(queue.map((candidate) => [candidate.key, prs[comparablePrKey(candidate)]?.headRefOid ?? null]));
35753
+ }
35754
+ async function rateLimitedOutcome() {
35755
+ const rateLimitWaitMs = await store.rateLimitWaitMs(now(), TEAM_REVIEW_RATE_LIMIT_RESOURCES) ?? secondaryRateLimitWaitMs(runtime.pollingError);
35756
+ return rateLimitWaitMs === null ? {
35757
+ failed: true,
35758
+ error: runtime.pollingError ?? void 0
35759
+ } : {
35760
+ failed: true,
35761
+ retryAfterMs: rateLimitWaitMs,
35762
+ error: runtime.pollingError ?? void 0
35623
35763
  };
35624
- if (entry.draft && !isThreadPlaceholderDraft(entry.draft)) {
35625
- if (!await requeue(key, entry.draft.reviewedHead)) return {
35626
- ok: false,
35627
- error: REQUEUE_REFUSAL
35764
+ }
35765
+ async function runTick() {
35766
+ runtime.pollingError = null;
35767
+ runtime.tickRateLimitWaitMs = null;
35768
+ const collected = await collectCandidates().catch((error) => {
35769
+ runtime.pollingError = errorMessage(error);
35770
+ log.warn(`[${TEAM_REVIEW_LANE_ID}] candidate search failed: ${runtime.pollingError}`);
35771
+ return null;
35772
+ });
35773
+ if (runtime.tickRateLimitWaitMs !== null) {
35774
+ runtime.pollingError = "GitHub rate limit asks to wait.";
35775
+ return {
35776
+ failed: true,
35777
+ retryAfterMs: runtime.tickRateLimitWaitMs,
35778
+ error: runtime.pollingError
35628
35779
  };
35629
- await markAskedFor(key, entry);
35780
+ }
35781
+ if (collected === null) {
35782
+ runtime.pollingError ??= "Could not look up your GitHub account or team members.";
35783
+ return rateLimitedOutcome();
35784
+ }
35785
+ const storeError = store.getSnapshot().freshness.error;
35786
+ if (storeError) {
35787
+ runtime.pollingError = storeError;
35788
+ return rateLimitedOutcome();
35789
+ }
35790
+ const { candidates, isComplete } = collected;
35791
+ const rateLimitWaitMs = isComplete ? null : await store.rateLimitWaitMs(now(), TEAM_REVIEW_RATE_LIMIT_RESOURCES);
35792
+ if (rateLimitWaitMs !== null) {
35793
+ runtime.pollingError = "GitHub rate limit asks to wait.";
35630
35794
  return {
35631
- ok: true,
35632
- key,
35633
- status: "queued"
35795
+ failed: true,
35796
+ retryAfterMs: rateLimitWaitMs,
35797
+ error: runtime.pollingError
35634
35798
  };
35635
35799
  }
35636
- if (entry.reviewedHead !== null) {
35637
- entry.reviewedHead = null;
35638
- entry.reviewAttempts = 0;
35639
- if (entry.liveHead) entry.requeuedHead = entry.liveHead;
35800
+ const isPruned = await pruneDeparted(new Set(candidates.map((candidate) => candidate.key)), isComplete);
35801
+ if (isPruned) watchAskedFor();
35802
+ const planned = headsToReview(candidates);
35803
+ const isStarted = await startReviews(planned.queue);
35804
+ const areThreadsChanged = runtime.tickRateLimitWaitMs === null ? await handleAnsweredThreads(candidates) : false;
35805
+ if (isPruned || planned.isDirty || areThreadsChanged || isStarted) await persist();
35806
+ if (runtime.tickRateLimitWaitMs !== null) {
35807
+ runtime.pollingError = "GitHub rate limit asks to wait.";
35808
+ return {
35809
+ failed: true,
35810
+ retryAfterMs: runtime.tickRateLimitWaitMs,
35811
+ error: runtime.pollingError
35812
+ };
35640
35813
  }
35641
- await markAskedFor(key, entry);
35642
- return {
35643
- ok: true,
35644
- key,
35645
- status: "queued"
35646
- };
35647
- }
35648
- async function requestReview(reference) {
35649
- if (loop.isStopped() || !hasLoadedState) return {
35650
- ok: false,
35651
- error: "Team review is not running"
35652
- };
35653
- const findKnownKey = () => Object.keys(state).find((key) => key.toLowerCase() === comparablePrKey(reference));
35654
- const knownKey = findKnownKey();
35655
- const knownEntry = knownKey === void 0 ? void 0 : state[knownKey];
35656
- if (knownKey !== void 0 && knownEntry) return requestKnownReview(knownKey, knownEntry);
35657
- if (!isTeamCandidate(comparablePrKey(reference)) && askedForSlotsInUse() >= 20) return {
35658
- ok: false,
35659
- error: `at most 20 pull requests outside your teams can wait for a review at once, and one frees when its review is posted or the operator marks it Not mine in the Reviews tab`
35660
- };
35661
- const label = prKey(reference.repo, reference.number);
35662
- const headRead = await store.requestPrHead(reference.repo, reference.number, "no-wait");
35663
- if (headRead.isRateLimited) return {
35664
- ok: false,
35665
- error: githubStoreRateLimitedError(headRead.waitMs)
35666
- };
35667
- if (headRead.value === null) return {
35668
- ok: false,
35669
- error: `could not read ${label} from GitHub`
35670
- };
35671
- const detailRead = await store.requestPrView(reference.repo, reference.number, headRead.value, "no-wait");
35672
- if (detailRead.isRateLimited) return {
35673
- ok: false,
35674
- error: githubStoreRateLimitedError(detailRead.waitMs)
35675
- };
35676
- const detail = detailRead.value;
35677
- if (!detail) return {
35678
- ok: false,
35679
- error: `could not read ${label} from GitHub`
35680
- };
35681
- const refusal = askedForRefusal(detail, self);
35682
- if (refusal) return {
35683
- ok: false,
35684
- error: `${label} cannot be reviewed: ${refusal}`
35685
- };
35686
- const raceKey = findKnownKey();
35687
- const raceEntry = raceKey === void 0 ? void 0 : state[raceKey];
35688
- if (raceKey !== void 0 && raceEntry) return requestKnownReview(raceKey, raceEntry);
35689
- const key = pullRequestKeyFromReference(detail.url) ?? label;
35690
- const entry = entryFor(key);
35691
- entry.liveHead = detail.headRefOid;
35692
- entry.requeuedHead = detail.headRefOid;
35693
- await markAskedFor(key, entry);
35694
- return {
35695
- ok: true,
35696
- key,
35697
- status: "queued"
35698
- };
35814
+ if (runtime.hasSlotFreedSinceSlotCount && runtime.waitingForSlot.length > 0 && !loop.isStopped()) setTimeoutFn(() => {
35815
+ loop.tick();
35816
+ }, 0);
35699
35817
  }
35700
35818
  async function start() {
35701
35819
  await loop.start(async () => {
35702
- state = await readState() || {};
35703
- for (const entry of Object.values(state)) entry.inFlight = false;
35820
+ runtime.state = await readState() || {};
35821
+ for (const entry of Object.values(runtime.state)) entry.inFlight = false;
35704
35822
  progressByKey.clear();
35705
35823
  emitStatus();
35706
35824
  const keepPaths = /* @__PURE__ */ new Set();
35707
- for (const entry of Object.values(state)) {
35825
+ for (const entry of Object.values(runtime.state)) {
35708
35826
  if (!entry.resumable) continue;
35709
35827
  keepPaths.add(entry.resumable.workDir);
35710
35828
  keepPaths.add(entry.resumable.worktreePath);
35711
35829
  }
35712
35830
  await beforeStart(keepPaths);
35713
- hasLoadedState = true;
35831
+ runtime.hasLoadedState = true;
35714
35832
  watchAskedFor();
35715
35833
  });
35716
35834
  }
35717
- function unregisterWatches() {
35718
- for (const name of watches.keys()) store.unregisterWatch(name);
35719
- watches.clear();
35720
- store.setWatchedKeys("team-review-departed", []);
35721
- store.setWatchedKeys(ASKED_FOR_WATCH_OWNER, []);
35722
- }
35723
35835
  async function refresh() {
35724
35836
  if (loop.isStopped()) return {
35725
35837
  ok: false,
@@ -35733,7 +35845,7 @@ function createTeamReviewPoller(deps) {
35733
35845
  });
35734
35846
  }
35735
35847
  async function stop() {
35736
- hasLoadedState = false;
35848
+ runtime.hasLoadedState = false;
35737
35849
  unregisterWatches();
35738
35850
  cancelPendingProgressEmit();
35739
35851
  await loop.stop();
@@ -35751,7 +35863,7 @@ function createTeamReviewPoller(deps) {
35751
35863
  requeue,
35752
35864
  requestReview,
35753
35865
  markNotMine,
35754
- _state: () => state
35866
+ _state: () => runtime.state
35755
35867
  };
35756
35868
  }
35757
35869
  //#endregion
@@ -43085,55 +43197,25 @@ function createLaneLedger({ ledgerPath = null, fsPromises = fs$1, nowFn = Date.n
43085
43197
  };
43086
43198
  }
43087
43199
  //#endregion
43088
- //#region server/core/transcript-tail-core.ts
43089
- function fileIdentity(stat) {
43090
- return `${Math.floor(coercedNumberOr(stat?.ino, 0))}:${Math.floor(coercedNumberOr(stat?.birthtimeMs, 0))}`;
43091
- }
43092
- function createTailState(stat, { path: filePath = null, head = null } = {}) {
43093
- const size = Math.max(0, Math.floor(coercedNumberOr(stat?.size, 0)));
43094
- return {
43095
- path: filePath,
43096
- identity: fileIdentity(stat),
43097
- size,
43098
- mtimeMs: coercedNumberOr(stat?.mtimeMs, 0),
43099
- offset: size,
43100
- carry: "",
43101
- head: typeof head === "string" ? head : null,
43102
- vendorState: null
43103
- };
43104
- }
43105
- function splitKeepingEmpty(carry, chunkText) {
43106
- const lines = `${carry || ""}${chunkText || ""}`.split(/\r?\n/);
43107
- return {
43108
- lines,
43109
- carry: lines.pop() || ""
43110
- };
43200
+ //#region server/trace/trace-wiring-context.ts
43201
+ var TRACE_SUFFIX = ".jsonl";
43202
+ var CHECKPOINT_SUFFIX = ".checkpoint.json";
43203
+ function trimOldest(entries, limit) {
43204
+ while (entries.size > limit) {
43205
+ const oldest = entries.keys().next().value;
43206
+ if (oldest === void 0) return;
43207
+ entries.delete(oldest);
43208
+ }
43111
43209
  }
43112
- function afterFirstBreak(text) {
43113
- const firstBreak = text.indexOf("\n");
43114
- if (firstBreak === -1) return "";
43115
- return text.slice(firstBreak + 1);
43210
+ function projectsRoot() {
43211
+ return claudeProjectsDir(process.env, os.homedir());
43116
43212
  }
43117
- function applyRead(state, { text = "", end = 0, stat = null, head = null, reset = false, dropPartial = false, keepEmptyLines = false } = {}) {
43118
- if (reset || dropPartial) state.carry = "";
43119
- if (reset) {
43120
- state.vendorState = null;
43121
- state.head = null;
43213
+ async function realProjectsRoot() {
43214
+ try {
43215
+ return await fs.promises.realpath(projectsRoot());
43216
+ } catch {
43217
+ return null;
43122
43218
  }
43123
- if (typeof head === "string" && head.length > 0) state.head = head;
43124
- const body = dropPartial ? afterFirstBreak(text) : text;
43125
- const split = keepEmptyLines ? splitKeepingEmpty(state.carry, body) : splitLines(state.carry, body);
43126
- state.carry = split.carry;
43127
- state.offset = Math.max(0, Math.floor(coercedNumberOr(end, state.offset)));
43128
- state.size = Math.max(state.offset, Math.floor(coercedNumberOr(stat?.size, state.offset)));
43129
- state.mtimeMs = coercedNumberOr(stat?.mtimeMs, state.mtimeMs);
43130
- if (stat) state.identity = fileIdentity(stat);
43131
- return split.lines;
43132
- }
43133
- function isTailCurrent(state, stat) {
43134
- if (!stat || fileIdentity(stat) !== state.identity) return false;
43135
- if (coercedNumberOr(stat.size, -1) !== state.size || state.offset < state.size) return false;
43136
- return coercedNumberOr(stat.mtimeMs, -1) === state.mtimeMs;
43137
43219
  }
43138
43220
  //#endregion
43139
43221
  //#region server/session/core/session-trace-core.ts
@@ -43271,77 +43353,14 @@ async function readSessionTracePage(request) {
43271
43353
  return readPageAfter(request);
43272
43354
  }
43273
43355
  //#endregion
43274
- //#region server/trace-wiring.ts
43275
- var TRACE_RETAIN_DAYS = 7;
43276
- var PRUNE_INTERVAL_MS$1 = 864e5;
43277
- var POLL_INTERVAL_MS = 2e3;
43278
- var MAX_REMEMBERED_FILE_REFUSALS = 64;
43279
- var MAX_REMEMBERED_CLOSED_SESSIONS = 512;
43280
- var TRACE_SUFFIX = ".jsonl";
43281
- var CHECKPOINT_SUFFIX = ".checkpoint.json";
43282
- var NO_BYTES = Buffer.alloc(0);
43356
+ //#region server/trace/trace-record-store.ts
43283
43357
  function isRewoundCursor(request, next) {
43284
43358
  if (request.endingAt !== void 0) return false;
43285
43359
  return next < request.after;
43286
43360
  }
43287
- async function isResumePointMidLine(handle, offset) {
43288
- if (offset <= 0) return false;
43289
- const byteBeforeOffset = Buffer.alloc(1);
43290
- const { bytesRead } = await handle.read(byteBeforeOffset, 0, 1, offset - 1);
43291
- if (bytesRead <= 0) return false;
43292
- return byteBeforeOffset[0] !== 10;
43293
- }
43294
- function trimOldest(entries, limit) {
43295
- while (entries.size > limit) {
43296
- const oldest = entries.keys().next().value;
43297
- if (oldest === void 0) return;
43298
- entries.delete(oldest);
43299
- }
43300
- }
43301
- function projectsRoot() {
43302
- return claudeProjectsDir(process.env, os.homedir());
43303
- }
43304
- async function realProjectsRoot() {
43305
- try {
43306
- return await fs.promises.realpath(projectsRoot());
43307
- } catch {
43308
- return null;
43309
- }
43310
- }
43311
- async function pruneTraceFiles({ traceDirectory, now = Date.now(), isBoundSessionId = () => false }) {
43312
- return (await pruneAgedFiles({
43313
- directory: traceDirectory,
43314
- suffixes: [CHECKPOINT_SUFFIX, TRACE_SUFFIX],
43315
- retainDays: TRACE_RETAIN_DAYS,
43316
- now,
43317
- isRetainedId: isBoundSessionId
43318
- })).length;
43319
- }
43320
- function createTraceWiring({ configPath = null, logger = console, debug = false, nowFn = Date.now, setIntervalFn = DEFAULT_TIMER_FNS.setIntervalFn, clearIntervalFn = DEFAULT_TIMER_FNS.clearIntervalFn, maxRememberedSubagents = 512 } = {}) {
43321
- const traceDirectory = configSiblingPath(configPath, "traces");
43322
- const emitter = new EventEmitter();
43323
- const bindingByGlimmervoidSessionId = /* @__PURE__ */ new Map();
43324
- const awaitingTranscriptByGlimmervoidSessionId = /* @__PURE__ */ new Map();
43325
- const pendingRecordsBySessionId = /* @__PURE__ */ new Map();
43326
- const closedSessionIds = /* @__PURE__ */ new Set();
43327
- const attachedSessions = /* @__PURE__ */ new WeakSet();
43328
- let pruneTimer = null;
43329
- let pollTimer = null;
43330
- let hasStarted = false;
43331
- let hasStopped = false;
43361
+ function createTraceRecordStore(context) {
43362
+ const { traceDirectory, emitter, laneLog, nowFn, bindingByGlimmervoidSessionId, pendingRecordsBySessionId } = context;
43332
43363
  let hasEnsuredDirectory = false;
43333
- let stopPromise = null;
43334
- const operationQueue = createSerialQueue();
43335
- const laneLog = createLaneLog({
43336
- prefix: "[trace]",
43337
- logger,
43338
- debugFlag: debug
43339
- });
43340
- function chain(step, failure) {
43341
- operationQueue.run(step).catch((error) => {
43342
- laneLog.warn(failure, { error: errorMessage(error) });
43343
- });
43344
- }
43345
43364
  function traceFilePath(glimmervoidSessionId) {
43346
43365
  if (!isSafePathSegment(glimmervoidSessionId)) return null;
43347
43366
  return path.join(traceDirectory, `${glimmervoidSessionId}${TRACE_SUFFIX}`);
@@ -43433,9 +43452,22 @@ function createTraceWiring({ configPath = null, logger = console, debug = false,
43433
43452
  async function flushEverySession() {
43434
43453
  for (const glimmervoidSessionId of [...pendingRecordsBySessionId.keys()]) await flushSession(glimmervoidSessionId);
43435
43454
  }
43436
- function committedOffsetOf(binding) {
43437
- return Math.max(0, binding.tailState.offset - Buffer.byteLength(binding.tailState.carry, "utf8"));
43438
- }
43455
+ return {
43456
+ traceFilePath,
43457
+ readTracePage,
43458
+ queueRecord,
43459
+ flushSession,
43460
+ flushEverySession
43461
+ };
43462
+ }
43463
+ //#endregion
43464
+ //#region server/trace/trace-checkpoints.ts
43465
+ function committedOffsetOf(binding) {
43466
+ return Math.max(0, binding.tailState.offset - Buffer.byteLength(binding.tailState.carry, "utf8"));
43467
+ }
43468
+ function createTraceCheckpoints(context, recordStore) {
43469
+ const { traceDirectory, maxRememberedSubagents, pendingRecordsBySessionId } = context;
43470
+ const { traceFilePath } = recordStore;
43439
43471
  function stampCommittedOffset(glimmervoidSessionId, transcriptOffset) {
43440
43472
  const records = pendingRecordsBySessionId.get(glimmervoidSessionId);
43441
43473
  if (!records || records.length === 0) return;
@@ -43529,6 +43561,70 @@ function createTraceWiring({ configPath = null, logger = console, debug = false,
43529
43561
  subagentOffsetByPath
43530
43562
  };
43531
43563
  }
43564
+ return {
43565
+ stampCommittedOffset,
43566
+ writeCheckpoint,
43567
+ checkpointFilePath,
43568
+ resumeStateFor
43569
+ };
43570
+ }
43571
+ //#endregion
43572
+ //#region server/core/transcript-tail-core.ts
43573
+ function fileIdentity(stat) {
43574
+ return `${Math.floor(coercedNumberOr(stat?.ino, 0))}:${Math.floor(coercedNumberOr(stat?.birthtimeMs, 0))}`;
43575
+ }
43576
+ function createTailState(stat, { path: filePath = null, head = null } = {}) {
43577
+ const size = Math.max(0, Math.floor(coercedNumberOr(stat?.size, 0)));
43578
+ return {
43579
+ path: filePath,
43580
+ identity: fileIdentity(stat),
43581
+ size,
43582
+ mtimeMs: coercedNumberOr(stat?.mtimeMs, 0),
43583
+ offset: size,
43584
+ carry: "",
43585
+ head: typeof head === "string" ? head : null,
43586
+ vendorState: null
43587
+ };
43588
+ }
43589
+ function splitKeepingEmpty(carry, chunkText) {
43590
+ const lines = `${carry || ""}${chunkText || ""}`.split(/\r?\n/);
43591
+ return {
43592
+ lines,
43593
+ carry: lines.pop() || ""
43594
+ };
43595
+ }
43596
+ function afterFirstBreak(text) {
43597
+ const firstBreak = text.indexOf("\n");
43598
+ if (firstBreak === -1) return "";
43599
+ return text.slice(firstBreak + 1);
43600
+ }
43601
+ function applyRead(state, { text = "", end = 0, stat = null, head = null, reset = false, dropPartial = false, keepEmptyLines = false } = {}) {
43602
+ if (reset || dropPartial) state.carry = "";
43603
+ if (reset) {
43604
+ state.vendorState = null;
43605
+ state.head = null;
43606
+ }
43607
+ if (typeof head === "string" && head.length > 0) state.head = head;
43608
+ const body = dropPartial ? afterFirstBreak(text) : text;
43609
+ const split = keepEmptyLines ? splitKeepingEmpty(state.carry, body) : splitLines(state.carry, body);
43610
+ state.carry = split.carry;
43611
+ state.offset = Math.max(0, Math.floor(coercedNumberOr(end, state.offset)));
43612
+ state.size = Math.max(state.offset, Math.floor(coercedNumberOr(stat?.size, state.offset)));
43613
+ state.mtimeMs = coercedNumberOr(stat?.mtimeMs, state.mtimeMs);
43614
+ if (stat) state.identity = fileIdentity(stat);
43615
+ return split.lines;
43616
+ }
43617
+ function isTailCurrent(state, stat) {
43618
+ if (!stat || fileIdentity(stat) !== state.identity) return false;
43619
+ if (coercedNumberOr(stat.size, -1) !== state.size || state.offset < state.size) return false;
43620
+ return coercedNumberOr(stat.mtimeMs, -1) === state.mtimeMs;
43621
+ }
43622
+ //#endregion
43623
+ //#region server/trace/trace-transcript-drain.ts
43624
+ function createTraceTranscriptDrain(context, recordStore, checkpoints) {
43625
+ const { laneLog, nowFn, pendingRecordsBySessionId } = context;
43626
+ const { queueRecord, flushSession } = recordStore;
43627
+ const { stampCommittedOffset, writeCheckpoint, resumeStateFor } = checkpoints;
43532
43628
  function queueSessionRecord(binding, reason) {
43533
43629
  queueRecord(binding.glimmervoidSessionId, {
43534
43630
  ts: nowFn(),
@@ -43555,7 +43651,7 @@ function createTraceWiring({ configPath = null, logger = console, debug = false,
43555
43651
  const refusalKey = `${filePath}:${reason}`;
43556
43652
  if (binding.notedFileRefusals.has(refusalKey)) return false;
43557
43653
  binding.notedFileRefusals.add(refusalKey);
43558
- trimOldest(binding.notedFileRefusals, MAX_REMEMBERED_FILE_REFUSALS);
43654
+ trimOldest(binding.notedFileRefusals, 64);
43559
43655
  if (reason === "missing") return false;
43560
43656
  queueRecord(binding.glimmervoidSessionId, {
43561
43657
  ts: nowFn(),
@@ -43696,84 +43792,28 @@ function createTraceWiring({ configPath = null, logger = console, debug = false,
43696
43792
  offset: committedOffsetAfterRead
43697
43793
  }));
43698
43794
  }
43699
- function predecessorAwaitingDrain(previous) {
43700
- if (!previous) return null;
43701
- if (previous.hasOpenedTranscript) return previous;
43702
- const inherited = previous.bindingBeforeFirstOpen;
43703
- previous.bindingBeforeFirstOpen = null;
43704
- return inherited;
43705
- }
43706
- async function bindSession(glimmervoidSessionId, vendorSessionId, vendor, requestedTranscriptPath) {
43707
- if (hasStopped || closedSessionIds.has(glimmervoidSessionId)) return;
43708
- const checkpointPath = checkpointFilePath(glimmervoidSessionId);
43709
- if (!checkpointPath) return;
43710
- const containedTranscript = await openContainedFile(requestedTranscriptPath, projectsRoot(), true);
43711
- if (!containedTranscript.ok && containedTranscript.reason === "missing") awaitingTranscriptByGlimmervoidSessionId.set(glimmervoidSessionId, {
43712
- id: vendorSessionId,
43713
- vendor,
43714
- transcriptPath: requestedTranscriptPath
43715
- });
43716
- if (!containedTranscript.ok) {
43717
- laneLog.warnOnce(`bind:${glimmervoidSessionId}:${containedTranscript.reason}`, "transcript refused", {
43718
- session: glimmervoidSessionId,
43719
- path: requestedTranscriptPath,
43720
- root: projectsRoot(),
43721
- reason: containedTranscript.reason
43722
- });
43723
- return;
43724
- }
43725
- awaitingTranscriptByGlimmervoidSessionId.delete(glimmervoidSessionId);
43726
- const transcriptPath = containedTranscript.file.realPath;
43727
- const transcriptStat = "handle" in containedTranscript.file ? containedTranscript.file.stat : null;
43728
- if ("handle" in containedTranscript.file) await containedTranscript.file.handle.close().catch(() => {});
43729
- const previous = bindingByGlimmervoidSessionId.get(glimmervoidSessionId);
43730
- if (previous) {
43731
- bindingByGlimmervoidSessionId.delete(glimmervoidSessionId);
43732
- await drainBinding(previous);
43733
- }
43734
- const resumed = transcriptStat ? await resumeStateFor(glimmervoidSessionId, transcriptPath, transcriptStat.size) : null;
43735
- const tailState = createTailState(transcriptStat, { path: transcriptPath });
43736
- tailState.offset = resumed ? resumed.offset : 0;
43737
- const binding = {
43738
- glimmervoidSessionId,
43739
- vendorSessionId,
43740
- vendor,
43741
- transcriptPath,
43742
- requestedTranscriptPath,
43743
- tailState,
43744
- subagentPathsWithoutOffset: new Set(resumed ? resumed.subagentPathsWithoutOffset : []),
43745
- subagentOffsetByPath: resumed ? resumed.subagentOffsetByPath : {},
43746
- notedFileRefusals: /* @__PURE__ */ new Set(),
43747
- committedOffsetByTranscriptPath: resumed ? resumed.committedOffsetByTranscriptPath : {},
43748
- checkpointWriter: createJsonStateWriter({
43749
- filePath: checkpointPath,
43750
- warn: (error) => {
43751
- laneLog.warn("checkpoint write failed", { error: errorMessage(error) });
43752
- }
43753
- }),
43754
- bindingBeforeFirstOpen: transcriptStat ? null : predecessorAwaitingDrain(previous),
43755
- isSkippingOversizedLine: false,
43756
- hasOpenedTranscript: transcriptStat !== null,
43757
- hasWarnedUnreadable: false,
43758
- isClosing: false
43759
- };
43760
- if (resumed) noteResumeOutcome(binding, resumed);
43761
- bindingByGlimmervoidSessionId.set(glimmervoidSessionId, binding);
43762
- await drainBinding(binding);
43763
- }
43764
- function noteVendorSession(glimmervoidSessionId, eventPayload) {
43765
- if (hasStopped || closedSessionIds.has(glimmervoidSessionId)) return;
43766
- const vendorSessionId = typeof eventPayload.id === "string" ? eventPayload.id : "";
43767
- const vendor = typeof eventPayload.vendor === "string" ? eventPayload.vendor : "claude";
43768
- if (!vendorSessionId || vendor !== "claude") return;
43769
- if (!traceFilePath(glimmervoidSessionId)) return;
43770
- const rawPath = typeof eventPayload.transcriptPath === "string" ? eventPayload.transcriptPath : "";
43771
- if (!rawPath) return;
43772
- const requestedTranscriptPath = path.resolve(rawPath);
43773
- const bound = bindingByGlimmervoidSessionId.get(glimmervoidSessionId);
43774
- if (bound && bound.vendorSessionId === vendorSessionId && bound.requestedTranscriptPath === requestedTranscriptPath) return;
43775
- chain(() => bindSession(glimmervoidSessionId, vendorSessionId, vendor, requestedTranscriptPath), "binding failed");
43776
- }
43795
+ return {
43796
+ noteSkippedBytes,
43797
+ queueFileRefusalNotice,
43798
+ noteResumeOutcome,
43799
+ mapAndAppend,
43800
+ commitPending,
43801
+ drainBinding
43802
+ };
43803
+ }
43804
+ //#endregion
43805
+ //#region server/trace/trace-subagent-capture.ts
43806
+ var NO_BYTES = Buffer.alloc(0);
43807
+ async function isResumePointMidLine(handle, offset) {
43808
+ if (offset <= 0) return false;
43809
+ const byteBeforeOffset = Buffer.alloc(1);
43810
+ const { bytesRead } = await handle.read(byteBeforeOffset, 0, 1, offset - 1);
43811
+ if (bytesRead <= 0) return false;
43812
+ return byteBeforeOffset[0] !== 10;
43813
+ }
43814
+ function createTraceSubagentCapture(context, drain) {
43815
+ const { laneLog, maxRememberedSubagents, bindingByGlimmervoidSessionId } = context;
43816
+ const { noteSkippedBytes, queueFileRefusalNotice, mapAndAppend, commitPending, drainBinding } = drain;
43777
43817
  async function readSubagentTranscript(glimmervoidSessionId, eventPayload) {
43778
43818
  const binding = bindingByGlimmervoidSessionId.get(glimmervoidSessionId);
43779
43819
  if (!binding) return;
@@ -43874,8 +43914,97 @@ function createTraceWiring({ configPath = null, logger = console, debug = false,
43874
43914
  bytes: bytesRead
43875
43915
  }));
43876
43916
  }
43917
+ return { readSubagentTranscript };
43918
+ }
43919
+ //#endregion
43920
+ //#region server/trace/trace-session-binding.ts
43921
+ function predecessorAwaitingDrain(previous) {
43922
+ if (!previous) return null;
43923
+ if (previous.hasOpenedTranscript) return previous;
43924
+ const inherited = previous.bindingBeforeFirstOpen;
43925
+ previous.bindingBeforeFirstOpen = null;
43926
+ return inherited;
43927
+ }
43928
+ function createTraceSessionBinding(context, deps) {
43929
+ const { laneLog, bindingByGlimmervoidSessionId, awaitingTranscriptByGlimmervoidSessionId, closedSessionIds, chain, isStopped } = context;
43930
+ const { traceFilePath, queueRecord, flushSession } = deps.recordStore;
43931
+ const { checkpointFilePath, resumeStateFor } = deps.checkpoints;
43932
+ const { noteResumeOutcome, drainBinding } = deps.drain;
43933
+ const { readSubagentTranscript } = deps.subagentCapture;
43934
+ const attachedSessions = /* @__PURE__ */ new WeakSet();
43935
+ async function bindSession(glimmervoidSessionId, vendorSessionId, vendor, requestedTranscriptPath) {
43936
+ if (isStopped() || closedSessionIds.has(glimmervoidSessionId)) return;
43937
+ const checkpointPath = checkpointFilePath(glimmervoidSessionId);
43938
+ if (!checkpointPath) return;
43939
+ const containedTranscript = await openContainedFile(requestedTranscriptPath, projectsRoot(), true);
43940
+ if (!containedTranscript.ok && containedTranscript.reason === "missing") awaitingTranscriptByGlimmervoidSessionId.set(glimmervoidSessionId, {
43941
+ id: vendorSessionId,
43942
+ vendor,
43943
+ transcriptPath: requestedTranscriptPath
43944
+ });
43945
+ if (!containedTranscript.ok) {
43946
+ laneLog.warnOnce(`bind:${glimmervoidSessionId}:${containedTranscript.reason}`, "transcript refused", {
43947
+ session: glimmervoidSessionId,
43948
+ path: requestedTranscriptPath,
43949
+ root: projectsRoot(),
43950
+ reason: containedTranscript.reason
43951
+ });
43952
+ return;
43953
+ }
43954
+ awaitingTranscriptByGlimmervoidSessionId.delete(glimmervoidSessionId);
43955
+ const transcriptPath = containedTranscript.file.realPath;
43956
+ const transcriptStat = "handle" in containedTranscript.file ? containedTranscript.file.stat : null;
43957
+ if ("handle" in containedTranscript.file) await containedTranscript.file.handle.close().catch(() => {});
43958
+ const previous = bindingByGlimmervoidSessionId.get(glimmervoidSessionId);
43959
+ if (previous) {
43960
+ bindingByGlimmervoidSessionId.delete(glimmervoidSessionId);
43961
+ await drainBinding(previous);
43962
+ }
43963
+ const resumed = transcriptStat ? await resumeStateFor(glimmervoidSessionId, transcriptPath, transcriptStat.size) : null;
43964
+ const tailState = createTailState(transcriptStat, { path: transcriptPath });
43965
+ tailState.offset = resumed ? resumed.offset : 0;
43966
+ const binding = {
43967
+ glimmervoidSessionId,
43968
+ vendorSessionId,
43969
+ vendor,
43970
+ transcriptPath,
43971
+ requestedTranscriptPath,
43972
+ tailState,
43973
+ subagentPathsWithoutOffset: new Set(resumed ? resumed.subagentPathsWithoutOffset : []),
43974
+ subagentOffsetByPath: resumed ? resumed.subagentOffsetByPath : {},
43975
+ notedFileRefusals: /* @__PURE__ */ new Set(),
43976
+ committedOffsetByTranscriptPath: resumed ? resumed.committedOffsetByTranscriptPath : {},
43977
+ checkpointWriter: createJsonStateWriter({
43978
+ filePath: checkpointPath,
43979
+ warn: (error) => {
43980
+ laneLog.warn("checkpoint write failed", { error: errorMessage(error) });
43981
+ }
43982
+ }),
43983
+ bindingBeforeFirstOpen: transcriptStat ? null : predecessorAwaitingDrain(previous),
43984
+ isSkippingOversizedLine: false,
43985
+ hasOpenedTranscript: transcriptStat !== null,
43986
+ hasWarnedUnreadable: false,
43987
+ isClosing: false
43988
+ };
43989
+ if (resumed) noteResumeOutcome(binding, resumed);
43990
+ bindingByGlimmervoidSessionId.set(glimmervoidSessionId, binding);
43991
+ await drainBinding(binding);
43992
+ }
43993
+ function noteVendorSession(glimmervoidSessionId, eventPayload) {
43994
+ if (isStopped() || closedSessionIds.has(glimmervoidSessionId)) return;
43995
+ const vendorSessionId = typeof eventPayload.id === "string" ? eventPayload.id : "";
43996
+ const vendor = typeof eventPayload.vendor === "string" ? eventPayload.vendor : "claude";
43997
+ if (!vendorSessionId || vendor !== "claude") return;
43998
+ if (!traceFilePath(glimmervoidSessionId)) return;
43999
+ const rawPath = typeof eventPayload.transcriptPath === "string" ? eventPayload.transcriptPath : "";
44000
+ if (!rawPath) return;
44001
+ const requestedTranscriptPath = path.resolve(rawPath);
44002
+ const bound = bindingByGlimmervoidSessionId.get(glimmervoidSessionId);
44003
+ if (bound && bound.vendorSessionId === vendorSessionId && bound.requestedTranscriptPath === requestedTranscriptPath) return;
44004
+ chain(() => bindSession(glimmervoidSessionId, vendorSessionId, vendor, requestedTranscriptPath), "binding failed");
44005
+ }
43877
44006
  function noteHookEvent(glimmervoidSessionId, eventRecord) {
43878
- if (hasStopped || closedSessionIds.has(glimmervoidSessionId)) return;
44007
+ if (isStopped() || closedSessionIds.has(glimmervoidSessionId)) return;
43879
44008
  const awaitedTranscript = awaitingTranscriptByGlimmervoidSessionId.get(glimmervoidSessionId);
43880
44009
  if (awaitedTranscript) {
43881
44010
  awaitingTranscriptByGlimmervoidSessionId.delete(glimmervoidSessionId);
@@ -43897,7 +44026,7 @@ function createTraceWiring({ configPath = null, logger = console, debug = false,
43897
44026
  function closeSession(glimmervoidSessionId) {
43898
44027
  closedSessionIds.add(glimmervoidSessionId);
43899
44028
  awaitingTranscriptByGlimmervoidSessionId.delete(glimmervoidSessionId);
43900
- trimOldest(closedSessionIds, MAX_REMEMBERED_CLOSED_SESSIONS);
44029
+ trimOldest(closedSessionIds, 512);
43901
44030
  chain(async () => {
43902
44031
  const binding = bindingByGlimmervoidSessionId.get(glimmervoidSessionId);
43903
44032
  if (!binding) return;
@@ -43906,7 +44035,7 @@ function createTraceWiring({ configPath = null, logger = console, debug = false,
43906
44035
  }, "final drain failed");
43907
44036
  }
43908
44037
  function appendConversationRecords(glimmervoidSessionId, records) {
43909
- if (hasStopped || !Array.isArray(records) || records.length === 0) return;
44038
+ if (isStopped() || !Array.isArray(records) || records.length === 0) return;
43910
44039
  for (const record of records) queueRecord(glimmervoidSessionId, record);
43911
44040
  chain(async () => {
43912
44041
  await flushSession(glimmervoidSessionId);
@@ -43931,6 +44060,69 @@ function createTraceWiring({ configPath = null, logger = console, debug = false,
43931
44060
  closeSession(session.id);
43932
44061
  });
43933
44062
  }
44063
+ return { attachSession };
44064
+ }
44065
+ //#endregion
44066
+ //#region server/trace-wiring.ts
44067
+ var TRACE_RETAIN_DAYS = 7;
44068
+ var PRUNE_INTERVAL_MS$1 = 864e5;
44069
+ var POLL_INTERVAL_MS = 2e3;
44070
+ async function pruneTraceFiles({ traceDirectory, now = Date.now(), isBoundSessionId = () => false }) {
44071
+ return (await pruneAgedFiles({
44072
+ directory: traceDirectory,
44073
+ suffixes: [CHECKPOINT_SUFFIX, TRACE_SUFFIX],
44074
+ retainDays: TRACE_RETAIN_DAYS,
44075
+ now,
44076
+ isRetainedId: isBoundSessionId
44077
+ })).length;
44078
+ }
44079
+ function createTraceWiring({ configPath = null, logger = console, debug = false, nowFn = Date.now, setIntervalFn = DEFAULT_TIMER_FNS.setIntervalFn, clearIntervalFn = DEFAULT_TIMER_FNS.clearIntervalFn, maxRememberedSubagents = 512 } = {}) {
44080
+ const traceDirectory = configSiblingPath(configPath, "traces");
44081
+ const emitter = new EventEmitter();
44082
+ const bindingByGlimmervoidSessionId = /* @__PURE__ */ new Map();
44083
+ const awaitingTranscriptByGlimmervoidSessionId = /* @__PURE__ */ new Map();
44084
+ const pendingRecordsBySessionId = /* @__PURE__ */ new Map();
44085
+ const closedSessionIds = /* @__PURE__ */ new Set();
44086
+ let pruneTimer = null;
44087
+ let pollTimer = null;
44088
+ let hasStarted = false;
44089
+ let hasStopped = false;
44090
+ let stopPromise = null;
44091
+ const operationQueue = createSerialQueue();
44092
+ const laneLog = createLaneLog({
44093
+ prefix: "[trace]",
44094
+ logger,
44095
+ debugFlag: debug
44096
+ });
44097
+ function chain(step, failure) {
44098
+ operationQueue.run(step).catch((error) => {
44099
+ laneLog.warn(failure, { error: errorMessage(error) });
44100
+ });
44101
+ }
44102
+ const context = {
44103
+ traceDirectory,
44104
+ emitter,
44105
+ laneLog,
44106
+ nowFn,
44107
+ maxRememberedSubagents,
44108
+ bindingByGlimmervoidSessionId,
44109
+ awaitingTranscriptByGlimmervoidSessionId,
44110
+ pendingRecordsBySessionId,
44111
+ closedSessionIds,
44112
+ chain,
44113
+ isStopped: () => hasStopped
44114
+ };
44115
+ const recordStore = createTraceRecordStore(context);
44116
+ const checkpoints = createTraceCheckpoints(context, recordStore);
44117
+ const drain = createTraceTranscriptDrain(context, recordStore, checkpoints);
44118
+ const { attachSession } = createTraceSessionBinding(context, {
44119
+ recordStore,
44120
+ checkpoints,
44121
+ drain,
44122
+ subagentCapture: createTraceSubagentCapture(context, drain)
44123
+ });
44124
+ const { readTracePage, flushEverySession } = recordStore;
44125
+ const { drainBinding } = drain;
43934
44126
  async function pollBoundTranscripts() {
43935
44127
  if (hasStopped) return;
43936
44128
  for (const binding of [...bindingByGlimmervoidSessionId.values()]) {