@atolis-hq/wake 0.3.57 → 0.3.59

package/dist/src/bootstrap/initialise.js

@@ -33,6 +33,8 @@ execution:
     standard: [fake]
     deep: [fake]
   defaultRunnerPool: standard
+  # A resumed agent session must have complete durable usage under this limit.
+  maxResumableSessionTokens: 200000
 
 # Tick dispatch cap and resident-loop idle backoff; the built-in defaults
 # are fine for a first run.

package/dist/src/bootstrap/version.js

@@ -108,4 +108,4 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "g17796f1";
+export const wakeVersion = "g58abde5";

package/dist/src/execution/application/execution-service.js

@@ -39,7 +39,7 @@ async function attemptExecution(runtime, activation, context) {
         stage: activation.stage,
         ...(context.sessionPolicy === undefined ? {} : { policy: context.sessionPolicy }),
     };
-    const resume = resumeContextFor(resumeCandidates, runner, resumeScope);
+    const resume = resumeContextFor(resumeCandidates, runner, resumeScope, runtime.config.maxResumableSessionTokens ?? 200_000);
     const existing = existingRun(prior, runtime.dependencies.clock, owner);
     if (existing !== undefined)
         return existing;
@@ -233,19 +233,22 @@ async function releasePreStartResources(runtime, activation, currentRunId, lease
 export function resumeSessionIdFor(prior, cli, scope, runnerName) {
     return resumeRunFor(prior, cli, runnerName, scope)?.agent?.metadata.sessionId;
 }
-function resumeContextFor(candidates, runner, scope) {
+function resumeContextFor(candidates, runner, scope, maximumTokens = 200_000) {
     if (runner.supportsSessionResume !== true)
         return {};
     const resumedRun = resumeRunFor(candidates, runner.cli, runner.name, scope);
     const sessionId = resumedRun?.agent?.metadata.sessionId;
+    const usageBaseline = sessionId === undefined
+        ? undefined
+        : usageBaselineFor(candidates, runner.cli, sessionId, scope, runner.name);
+    if (sessionId === undefined ||
+        usageBaseline === undefined ||
+        usageBaseline.input + usageBaseline.output > maximumTokens)
+        return {};
     return {
-        ...(sessionId === undefined ? {} : { sessionId }),
+        sessionId,
         ...(resumedRun?.startedAt === undefined ? {} : { startedAt: resumedRun.startedAt }),
-        ...(sessionId === undefined
-            ? {}
-            : {
-                usageBaseline: usageBaselineFor(candidates, runner.cli, sessionId, scope, runner.name),
-            }),
+        usageBaseline,
     };
 }
 function resumeRunFor(prior, cli, runnerName, scope) {

package/dist/src/execution/contracts/config.js

@@ -31,5 +31,6 @@ export const executionConfigSchema = z
     leaseDurationMs: z.number().int().positive().optional(),
     leaseRenewalIntervalMs: z.number().int().positive().optional(),
     maxAmbiguityReconciliationAttempts: z.number().int().positive().optional(),
+    maxResumableSessionTokens: z.number().int().positive().default(200_000),
 })
     .strict();

package/dist/src/integrations/github/infrastructure/client-reads.js

@@ -50,15 +50,16 @@ export async function listPullRequests(octokit, cache, owner, repo, maxResults)
     });
     return pullRequests.map(normalizePullRequestState);
 }
-export async function listReviews(octokit, cache, owner, repo, pullNumber, pageSize) {
+export async function listReviews(octokit, cache, owner, repo, pullNumber, options) {
     const reviews = await fetchPaginatedWithEtag({
         cache,
         key: `reviews:${owner}/${repo}#${pullNumber}`,
+        ...(options.maxResults === undefined ? {} : { maxResults: options.maxResults }),
         pages: (headers) => octokit.paginate.iterator(octokit.rest.pulls.listReviews, {
             owner,
             repo,
             pull_number: pullNumber,
-            per_page: pageSize,
+            per_page: boundedCommentPageSize(options),
             ...(headers === undefined ? {} : { headers }),
         }),
     });
@@ -71,15 +72,16 @@ export async function listReviews(octokit, cache, owner, repo, pullNumber, pageS
         ...(review.user === undefined ? {} : { user: review.user }),
     }));
 }
-export async function listReviewComments(octokit, cache, owner, repo, pullNumber, pageSize) {
+export async function listReviewComments(octokit, cache, owner, repo, pullNumber, options) {
     const comments = await fetchPaginatedWithEtag({
         cache,
         key: `review-comments:${owner}/${repo}#${pullNumber}`,
+        ...(options.maxResults === undefined ? {} : { maxResults: options.maxResults }),
         pages: (headers) => octokit.paginate.iterator(octokit.rest.pulls.listReviewComments, {
             owner,
             repo,
             pull_number: pullNumber,
-            per_page: Math.min(pageSize, 100),
+            per_page: boundedCommentPageSize(options),
             ...(headers === undefined ? {} : { headers }),
         }),
     });
@@ -94,37 +96,40 @@ export async function listReviewComments(octokit, cache, owner, repo, pullNumber
         ...(comment.side === undefined ? {} : { side: comment.side }),
     }));
 }
-export async function listPullRequestFiles(octokit, cache, owner, repo, pullNumber) {
+export async function listPullRequestFiles(octokit, cache, owner, repo, pullNumber, maxResults) {
     const files = await fetchPaginatedWithEtag({
         cache,
         key: `pull-files:${owner}/${repo}#${pullNumber}`,
+        ...(maxResults === undefined ? {} : { maxResults }),
         pages: (headers) => octokit.paginate.iterator(octokit.rest.pulls.listFiles, {
             owner,
             repo,
             pull_number: pullNumber,
-            per_page: 100,
+            per_page: boundedPageSize(maxResults),
             ...(headers === undefined ? {} : { headers }),
         }),
     });
     return files.map((file) => file.filename);
 }
-export function listCheckRunsForRef(octokit, cache, owner, repo, ref) {
+export function listCheckRunsForRef(octokit, cache, owner, repo, ref, maxResults) {
     return fetchPaginatedWithEtag({
         cache,
         key: `check-runs:${owner}/${repo}@${ref}`,
+        ...(maxResults === undefined ? {} : { maxResults }),
         pages: (headers) => octokit.paginate.iterator(octokit.rest.checks.listForRef, {
             owner,
             repo,
             ref,
-            per_page: 100,
+            per_page: boundedPageSize(maxResults),
             ...(headers === undefined ? {} : { headers }),
         }),
     });
 }
-export function getCombinedStatusForRef(octokit, cache, owner, repo, ref) {
+export function getCombinedStatusForRef(octokit, cache, owner, repo, ref, maxResults) {
     return fetchPaginatedWithEtag({
         cache,
         key: `combined-status:${owner}/${repo}@${ref}`,
+        ...(maxResults === undefined ? {} : { maxResults }),
         pages: (headers) => ({
             async *[Symbol.asyncIterator]() {
                 let page = 1;
@@ -134,14 +139,14 @@ export function getCombinedStatusForRef(octokit, cache, owner, repo, ref) {
                         owner,
                         repo,
                         ref,
-                        per_page: 100,
+                        per_page: boundedPageSize(maxResults),
                         page,
                         ...(headers === undefined ? {} : { headers }),
                     });
                     const statuses = response.data.statuses;
                     count += statuses.length;
                     yield { data: statuses, headers: response.headers };
-                    if (statuses.length < 100 || count >= response.data.total_count)
+                    if (statuses.length < boundedPageSize(maxResults) || count >= response.data.total_count)
                         return;
                     page += 1;
                 }
@@ -215,11 +220,12 @@ export async function listIssueComments(octokit, cache, owner, repo, issueNumber
     const comments = await fetchPaginatedWithEtag({
         cache,
         key: `issue-comments:${owner}/${repo}#${issueNumber}:since:${options.since ?? 'bootstrap'}`,
+        ...(options.maxResults === undefined ? {} : { maxResults: options.maxResults }),
         pages: (headers) => octokit.paginate.iterator(octokit.rest.issues.listComments, {
             owner,
             repo,
             issue_number: issueNumber,
-            per_page: Math.min(options.pageSize, 100),
+            per_page: boundedCommentPageSize(options),
             ...(options.since === undefined ? {} : { since: options.since }),
             ...(headers === undefined ? {} : { headers }),
         }),
@@ -232,3 +238,9 @@ export async function listIssueComments(octokit, cache, owner, repo, issueNumber
         ...(comment.user === undefined ? {} : { user: comment.user }),
     }));
 }
+function boundedPageSize(maxResults) {
+    return Math.min(maxResults ?? 100, 100);
+}
+function boundedCommentPageSize(options) {
+    return Math.min(options.pageSize, boundedPageSize(options.maxResults));
+}

package/dist/src/integrations/github/infrastructure/client.js

@@ -33,14 +33,8 @@ export function createGitHubClient(token) {
     });
     const cache = createEtagCache();
     return {
+        ...createGitHubReadClient(octokit, cache),
         authenticatedLogin: async () => (await octokit.rest.users.getAuthenticated()).data.login,
-        listIssues: (owner, repo, maxResults, since) => listIssues(octokit, cache, owner, repo, maxResults, since),
-        listPullRequests: (owner, repo, maxResults) => listPullRequests(octokit, cache, owner, repo, maxResults),
-        listIssueComments: (owner, repo, issueNumber, pageSize, since) => listIssueComments(octokit, cache, owner, repo, issueNumber, {
-            pageSize,
-            ...(since === undefined ? {} : { since }),
-        }),
-        listReviewComments: (owner, repo, pullNumber, pageSize) => listReviewComments(octokit, cache, owner, repo, pullNumber, pageSize),
         collaboratorPermission: async (owner, repo, login) => {
             const { data } = await octokit.rest.repos.getCollaboratorPermissionLevel({
                 owner,
@@ -49,7 +43,6 @@ export function createGitHubClient(token) {
             });
             return providerPermission(data.permission);
         },
-        getIssueLabels: (owner, repo, issueNumber) => getIssueLabels(octokit, cache, owner, repo, issueNumber),
         getIssueLabelsFresh: async (owner, repo, issueNumber) => {
             const response = await octokit.rest.issues.get({ owner, repo, issue_number: issueNumber });
             return response.data.labels.flatMap((label) => typeof label === 'string' ? [label] : label.name === undefined ? [] : [label.name]);
@@ -66,13 +59,32 @@ export function createGitHubClient(token) {
                 labels: [...labels],
             });
         },
+        deliver: (command) => deliver(octokit, command),
+    };
+}
+function createGitHubReadClient(octokit, cache) {
+    return {
+        listIssues: (owner, repo, maxResults, since) => listIssues(octokit, cache, owner, repo, maxResults, since),
+        listPullRequests: (owner, repo, maxResults) => listPullRequests(octokit, cache, owner, repo, maxResults),
+        listIssueComments: (owner, repo, issueNumber, pageSize, since, maxResults) => listIssueComments(octokit, cache, owner, repo, issueNumber, {
+            pageSize,
+            ...(since === undefined ? {} : { since }),
+            ...(maxResults === undefined ? {} : { maxResults }),
+        }),
+        listReviewComments: (owner, repo, pullNumber, pageSize, maxResults) => listReviewComments(octokit, cache, owner, repo, pullNumber, {
+            pageSize,
+            ...(maxResults === undefined ? {} : { maxResults }),
+        }),
+        getIssueLabels: (owner, repo, issueNumber) => getIssueLabels(octokit, cache, owner, repo, issueNumber),
         getPullRequest: (owner, repo, pullNumber) => getPullRequest(octokit, cache, owner, repo, pullNumber),
-        listReviews: (owner, repo, pullNumber, pageSize) => listReviews(octokit, cache, owner, repo, pullNumber, pageSize),
-        listCheckRunsForRef: (owner, repo, ref) => listCheckRunsForRef(octokit, cache, owner, repo, ref),
-        listPullRequestFiles: (owner, repo, pullNumber) => listPullRequestFiles(octokit, cache, owner, repo, pullNumber),
-        getCombinedStatusForRef: (owner, repo, ref) => getCombinedStatusForRef(octokit, cache, owner, repo, ref),
+        listReviews: (owner, repo, pullNumber, pageSize, maxResults) => listReviews(octokit, cache, owner, repo, pullNumber, {
+            pageSize,
+            ...(maxResults === undefined ? {} : { maxResults }),
+        }),
+        listCheckRunsForRef: (owner, repo, ref, maxResults) => listCheckRunsForRef(octokit, cache, owner, repo, ref, maxResults),
+        listPullRequestFiles: (owner, repo, pullNumber, maxResults) => listPullRequestFiles(octokit, cache, owner, repo, pullNumber, maxResults),
+        getCombinedStatusForRef: (owner, repo, ref, maxResults) => getCombinedStatusForRef(octokit, cache, owner, repo, ref, maxResults),
         branch: (owner, repo, name) => branch(octokit, cache, owner, repo, name),
-        deliver: (command) => deliver(octokit, command),
     };
 }
 function providerPermission(permission) {

package/dist/src/integrations/github/infrastructure/comment-source.js

@@ -7,7 +7,7 @@ export async function reviewCommentEventsFor(context, pullRequests) {
         return { drafts: [], succeeded: true };
     const items = await Promise.all(pullRequests.map(async (pullRequest) => {
         try {
-            const comments = await context.client.listReviewComments(context.owner, context.repo, pullRequest.number, context.config.polling.commentPageSize);
+            const comments = await context.client.listReviewComments(context.owner, context.repo, pullRequest.number, context.config.polling.commentPageSize, context.config.polling.maxPerRepo);
             return {
                 succeeded: true,
                 drafts: (await Promise.all(comments.map((comment) => issueCommentEventsForComment(context, pullRequest, comment)))).flat(),
@@ -23,7 +23,7 @@ export async function reviewCommentEventsFor(context, pullRequests) {
 export async function reviewEventsFor(context, pullRequests) {
     const items = await Promise.all(pullRequests.map(async (pullRequest) => {
         try {
-            const reviews = await context.client.listReviews(context.owner, context.repo, pullRequest.number, context.config.polling.commentPageSize);
+            const reviews = await context.client.listReviews(context.owner, context.repo, pullRequest.number, context.config.polling.commentPageSize, context.config.polling.maxPerRepo);
             return {
                 succeeded: true,
                 drafts: reviews.flatMap((review) => githubReviewObservation({
@@ -44,7 +44,7 @@ export async function reviewEventsFor(context, pullRequests) {
 export async function issueCommentEventsFor(context, issues, since) {
     const items = await Promise.all(issues.map(async (issue) => {
         try {
-            const comments = await context.client.listIssueComments(context.owner, context.repo, issue.number, context.config.polling.commentPageSize, since);
+            const comments = await context.client.listIssueComments(context.owner, context.repo, issue.number, context.config.polling.commentPageSize, since, context.config.polling.maxPerRepo);
             return {
                 succeeded: true,
                 drafts: (await Promise.all(comments.map((comment) => issueCommentEventsForComment(context, issue, comment)))).flat(),

package/dist/src/integrations/github/infrastructure/pr-source.js

@@ -18,8 +18,8 @@ export function createGitHubPullRequestSource(input) {
                 signal.throwIfAborted();
                 const headRevision = fallback(pullRequest.head?.sha, pullRequest.updated_at);
                 const [evidence, changedFiles] = await Promise.all([
-                    readCheckEvidence(input.client, owner, repo, headRevision),
-                    readChangedFiles(input.client, owner, repo, pullRequest.number),
+                    readCheckEvidence(input.client, owner, repo, headRevision, input.maxResults),
+                    readChangedFiles(input.client, owner, repo, pullRequest.number, input.maxResults),
                 ]);
                 return pullRequestObservation({
                     repository: input.repository,
@@ -91,11 +91,11 @@ function normalizeCheckEvidence(checkRuns, statuses) {
         return PullRequestCheckState.Passing;
     return PullRequestCheckState.Unknown;
 }
-async function readCheckEvidence(client, owner, repo, headRevision) {
+async function readCheckEvidence(client, owner, repo, headRevision, maxResults) {
     try {
         const [checkRuns, statuses] = await Promise.all([
-            client.listCheckRunsForRef(owner, repo, headRevision),
-            client.getCombinedStatusForRef(owner, repo, headRevision),
+            client.listCheckRunsForRef(owner, repo, headRevision, maxResults),
+            client.getCombinedStatusForRef(owner, repo, headRevision, maxResults),
         ]);
         return { available: true, checkRuns, statuses };
     }
@@ -103,9 +103,9 @@ async function readCheckEvidence(client, owner, repo, headRevision) {
         return { available: false, checkRuns: [], statuses: [] };
     }
 }
-async function readChangedFiles(client, owner, repo, pullNumber) {
+async function readChangedFiles(client, owner, repo, pullNumber, maxResults) {
     try {
-        return await client.listPullRequestFiles(owner, repo, pullNumber);
+        return await client.listPullRequestFiles(owner, repo, pullNumber, maxResults);
     }
     catch {
         return undefined;

package/dist/src/integrations/github/infrastructure/source.js

@@ -54,15 +54,15 @@ function limitGitHubSourceClient(client, requests) {
         ...client,
         listIssues: (owner, repo, maxResults, since) => requests.run(() => client.listIssues(owner, repo, maxResults, since)),
         listPullRequests: (owner, repo, maxResults) => requests.run(() => client.listPullRequests(owner, repo, maxResults)),
-        listCheckRunsForRef: (owner, repo, ref) => requests.run(() => client.listCheckRunsForRef(owner, repo, ref)),
-        getCombinedStatusForRef: (owner, repo, ref) => requests.run(() => client.getCombinedStatusForRef(owner, repo, ref)),
-        listPullRequestFiles: (owner, repo, pullNumber) => requests.run(() => client.listPullRequestFiles(owner, repo, pullNumber)),
-        listIssueComments: (owner, repo, issueNumber, pageSize, since) => requests.run(() => client.listIssueComments(owner, repo, issueNumber, pageSize, since)),
-        listReviews: (owner, repo, pullNumber, pageSize) => requests.run(() => client.listReviews(owner, repo, pullNumber, pageSize)),
+        listCheckRunsForRef: (owner, repo, ref, maxResults) => requests.run(() => client.listCheckRunsForRef(owner, repo, ref, maxResults)),
+        getCombinedStatusForRef: (owner, repo, ref, maxResults) => requests.run(() => client.getCombinedStatusForRef(owner, repo, ref, maxResults)),
+        listPullRequestFiles: (owner, repo, pullNumber, maxResults) => requests.run(() => client.listPullRequestFiles(owner, repo, pullNumber, maxResults)),
+        listIssueComments: (owner, repo, issueNumber, pageSize, since, maxResults) => requests.run(() => client.listIssueComments(owner, repo, issueNumber, pageSize, since, maxResults)),
+        listReviews: (owner, repo, pullNumber, pageSize, maxResults) => requests.run(() => client.listReviews(owner, repo, pullNumber, pageSize, maxResults)),
         ...(client.listReviewComments === undefined
             ? {}
             : {
-                listReviewComments: (owner, repo, pullNumber, pageSize) => requests.run(() => client.listReviewComments(owner, repo, pullNumber, pageSize)),
+                listReviewComments: (owner, repo, pullNumber, pageSize, maxResults) => requests.run(() => client.listReviewComments(owner, repo, pullNumber, pageSize, maxResults)),
             }),
         ...(client.collaboratorPermission === undefined
             ? {}

package/dist/src/persistence/application/projection-runner.js

@@ -39,7 +39,22 @@ export class ProjectionRunner {
         if (this.caughtUpToGlobalPosition !== undefined &&
             latestGlobalPosition <= this.caughtUpToGlobalPosition)
             return 0;
-        const counts = await Promise.all(this.registered.map((definition) => this.applyFrom(definition, allEvents, limit)));
+        let failed = false;
+        let firstFailure;
+        const counts = await Promise.all(this.registered.map(async (definition) => {
+            try {
+                return await this.applyFrom(definition, allEvents, limit);
+            }
+            catch (error) {
+                if (!failed) {
+                    failed = true;
+                    firstFailure = error;
+                }
+                return 0;
+            }
+        }));
+        if (failed)
+            throw firstFailure;
         if (counts.every((count) => count < limit))
             this.caughtUpToGlobalPosition = latestGlobalPosition;
         return counts.reduce((total, count) => total + count, 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.3.57",
+  "version": "0.3.59",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {