@atolis-hq/wake 0.3.56 → 0.3.58

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 = "ga125b02";
+export const wakeVersion = "g82612c6";

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/application/agent-context-reader.js

@@ -9,7 +9,7 @@ export function createGitHubAgentContextReader(journal, resources, options = {})
     const commentHistory = createCommentHistoryReader(journal, resources, options);
     return {
         async forWorkItem(workItemId, options) {
-            const comments = await commentHistory.forWorkItem(workItemId, options);
+            const comments = boundedAgentContextComments(await commentHistory.forWorkItem(workItemId, options));
             return {
                 ...(await currentWorkItemContent(journal, resources, workItemId)),
                 comments,
@@ -18,6 +18,64 @@ export function createGitHubAgentContextReader(journal, resources, options = {})
         },
     };
 }
+const maximumAgentContextComments = 12;
+const maximumAgentContextCommentCharacters = 8_000;
+const maximumAgentContextCharacters = 48_000;
+const truncationNotice = '\n[Wake truncated this historical comment for context bounds.]';
+function boundedAgentContextComments(comments) {
+    const indexed = comments.map((comment, index) => ({ comment, index }));
+    const latestWakeReviewerFeedback = [...indexed]
+        .reverse()
+        .find(({ comment }) => isWakeReviewerFeedback(comment));
+    const latestWakeAgentArtifact = [...indexed]
+        .reverse()
+        .find(({ comment }) => isWakeAgentArtifact(comment));
+    const protectedWakeArtifacts = [latestWakeReviewerFeedback, latestWakeAgentArtifact].flatMap((candidate, index, values) => candidate === undefined || values.slice(0, index).some((value) => value === candidate)
+        ? []
+        : [candidate]);
+    const retained = [];
+    let characters = 0;
+    for (const artifact of protectedWakeArtifacts) {
+        const remaining = maximumAgentContextCharacters - characters;
+        if (remaining <= 0)
+            break;
+        const body = truncateComment(artifact.comment.body, Math.min(maximumAgentContextCommentCharacters, remaining));
+        retained.push({ ...artifact, comment: { ...artifact.comment, body } });
+        characters += body.length;
+    }
+    for (const candidate of [...indexed].reverse()) {
+        const { comment } = candidate;
+        if ((isWakeDelivery(comment.body) && !protectedWakeArtifacts.includes(candidate)) ||
+            protectedWakeArtifacts.includes(candidate) ||
+            retained.length === maximumAgentContextComments)
+            continue;
+        const remaining = maximumAgentContextCharacters - characters;
+        if (remaining <= 0)
+            break;
+        const body = truncateComment(comment.body, Math.min(maximumAgentContextCommentCharacters, remaining));
+        retained.push({ ...candidate, comment: { ...comment, body } });
+        characters += body.length;
+    }
+    return retained.sort((left, right) => left.index - right.index).map(({ comment }) => comment);
+}
+function isWakeDelivery(body) {
+    return /<!--\s*wake:delivery:[^\s>]+\s*-->/.test(body);
+}
+function isWakeReviewerFeedback(comment) {
+    return (comment.body.includes('<!-- wake:agent -->') &&
+        (comment.body.includes('**Outcome:** 🔴 Changes Requested') ||
+            /"watchGateVerdict"[\s\S]*"outcome"\s*:\s*"REJECTED"/.test(comment.body)));
+}
+function isWakeAgentArtifact(comment) {
+    return comment.body.includes('<!-- wake:agent -->') && isWakeDelivery(comment.body);
+}
+function truncateComment(body, maximumCharacters) {
+    if (body.length <= maximumCharacters)
+        return body;
+    if (maximumCharacters <= truncationNotice.length)
+        return body.slice(0, maximumCharacters);
+    return `${body.slice(0, maximumCharacters - truncationNotice.length)}${truncationNotice}`;
+}
 async function currentWorkItemContent(journal, resources, workItemId) {
     const primary = (await resources.correlationsForWork(workItemId)).find((correlation) => correlation.role === ResourceCorrelationRole.Primary);
     if (primary === 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.56",
+  "version": "0.3.58",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {