@atolis-hq/wake 0.2.31 → 0.2.32

package/dist/src/adapters/github/github-client.js

@@ -66,6 +66,14 @@ export function createGitHubClient(token) {
                 }),
             });
         },
+        async getIssue(owner, repo, issueNumber) {
+            const { data } = await octokit.rest.issues.get({
+                owner,
+                repo,
+                issue_number: issueNumber,
+            });
+            return data;
+        },
         async createComment(owner, repo, issueNumber, body) {
             return octokit.rest.issues.createComment({
                 owner,

package/dist/src/adapters/github/github-issues-work-source.js

@@ -185,6 +185,9 @@ export async function readControlPlaneUiUrl(wakeRoot) {
         return undefined;
     }
 }
+function isGitHubNotFound(error) {
+    return error instanceof Error && error.status === 404;
+}
 export function formatGitHubError(error) {
     if (error instanceof Error) {
         const octokit = error;
@@ -301,6 +304,71 @@ export function createGitHubIssuesWorkSource(deps) {
         return deps.stateStore.readIssueState(workItemKey);
     }
     return {
+        async refreshForDispatch(input) {
+            const repoRef = input.projection.issue.repo;
+            if (deps.client.getIssue === undefined) {
+                return null;
+            }
+            if (!deps.config.sources.github.repos.includes(repoRef)) {
+                return null;
+            }
+            const [owner, repo] = repoRef.split('/');
+            if (owner === undefined || repo === undefined) {
+                return null;
+            }
+            const ingestedAt = deps.now().toISOString();
+            let issue;
+            try {
+                issue = await deps.client.getIssue(owner, repo, input.projection.issue.number);
+            }
+            catch (error) {
+                if (isGitHubNotFound(error)) {
+                    return {
+                        events: [],
+                        sourceRevision: `github:issue:${repoRef}#${input.projection.issue.number}@missing`,
+                        sourceExists: false,
+                    };
+                }
+                throw error;
+            }
+            const events = [];
+            if (input.projection.issue.updatedAt !== issue.updated_at) {
+                events.push(normalizeTicketUpsert({
+                    repo: repoRef,
+                    issue,
+                    ingestedAt,
+                    expectedEcho: isExpectedLabelEcho(issue, input.projection),
+                }));
+            }
+            const comments = await deps.client.listComments(owner, repo, input.projection.issue.number, deps.config.sources.github.polling.commentPageSize);
+            let latestCommentRevision = '';
+            for (const comment of comments) {
+                if (comment.updated_at > latestCommentRevision) {
+                    latestCommentRevision = comment.updated_at;
+                }
+                const known = input.projection.comments.find((entry) => entry.id === String(comment.id));
+                if (known?.updatedAt === comment.updated_at) {
+                    continue;
+                }
+                if (input.projection.wake.expectedEcho.commentIds.includes(String(comment.id))) {
+                    continue;
+                }
+                events.push(normalizeTicketCommentEvent({
+                    repo: repoRef,
+                    issueNumber: input.projection.issue.number,
+                    comment,
+                    ingestedAt,
+                    ...(deps.selfLogin === undefined ? {} : { selfLogin: deps.selfLogin }),
+                    ...(known?.updatedAt === undefined ? {} : { existingUpdatedAt: known.updatedAt }),
+                }));
+            }
+            return {
+                events,
+                sourceRevision: latestCommentRevision.length > 0
+                    ? `github:issue:${repoRef}#${issue.number}@${issue.updated_at};comments@${latestCommentRevision}`
+                    : `github:issue:${repoRef}#${issue.number}@${issue.updated_at}`,
+            };
+        },
         async pollEvents(_input) {
             const ingestedAt = deps.now().toISOString();
             const events = [];

package/dist/src/core/sink-router.js

@@ -4,6 +4,18 @@ export function createWorkSourceFanIn(sources) {
             const batches = await Promise.all(sources.map((source) => source.pollEvents(input)));
             return batches.flat();
         },
+        async refreshForDispatch(input) {
+            for (const source of sources) {
+                if (source.refreshForDispatch === undefined) {
+                    continue;
+                }
+                const result = await source.refreshForDispatch(input);
+                if (result !== null) {
+                    return result;
+                }
+            }
+            return null;
+        },
     };
 }
 function intentKind(event) {

package/dist/src/core/tick-runner.js

@@ -21,6 +21,15 @@ function latestHumanCommentId(candidate) {
     const human = candidate.comments.filter((c) => !c.isBotAuthored);
     return human.at(-1)?.id;
 }
+function projectedSourceRevision(projection) {
+    const latestCommentUpdatedAt = projection.comments
+        .map((comment) => comment.updatedAt)
+        .sort()
+        .at(-1);
+    return latestCommentUpdatedAt === undefined
+        ? `${projection.issue.repo}#${projection.issue.number}@${projection.issue.updatedAt}`
+        : `${projection.issue.repo}#${projection.issue.number}@${projection.issue.updatedAt};comments@${latestCommentUpdatedAt}`;
+}
 function isLateralReadOnlyAction(action, config) {
     return isCustomCommandAction(action, config);
 }
@@ -221,6 +230,18 @@ export function createTickRunner(deps) {
                 processStartedAt: record.workerProcessStartedAt,
             }));
     }
+    async function hasSchedulerCapacity(now) {
+        const runRecords = await deps.stateStore.listRunRecords();
+        for (const record of runRecords) {
+            if (record.status !== 'running') {
+                continue;
+            }
+            if (await isRunningRecordActive(record, now)) {
+                return false;
+            }
+        }
+        return true;
+    }
     async function parkConfigDriftedProjections(projections) {
         let parked = false;
         for (const projection of projections) {
@@ -314,10 +335,31 @@ export function createTickRunner(deps) {
             if (await parkConfigDriftedProjections(projections)) {
                 return { status: 'processed' };
             }
-            const candidate = projections.find((issue) => policy.resolveNextEligibleAction(issue, deps.config) !== null);
+            let candidate = projections.find((issue) => policy.resolveNextEligibleAction(issue, deps.config) !== null);
             if (candidate === undefined) {
                 return { status: 'idle' };
             }
+            let sourceRevision = projectedSourceRevision(candidate);
+            let refresh;
+            try {
+                refresh = await deps.workSource.refreshForDispatch?.({ projection: candidate });
+            }
+            catch {
+                return { status: 'idle' };
+            }
+            if (refresh !== undefined && refresh !== null) {
+                if (refresh.sourceExists === false) {
+                    return { status: 'idle' };
+                }
+                sourceRevision = refresh.sourceRevision;
+                if (refresh.events.length > 0) {
+                    await ingestInboundEvents(refresh.events);
+                    candidate = (await deps.stateStore.readIssueState(candidate.workItemKey)) ?? candidate;
+                }
+            }
+            if (policy.resolveNextEligibleAction(candidate, deps.config) === null) {
+                return { status: 'idle' };
+            }
             const workflow = workflowForProjection(candidate, deps.config);
             if (workflow === null) {
                 return { status: 'idle' };
@@ -444,6 +486,9 @@ export function createTickRunner(deps) {
             if (routing === null) {
                 return { status: 'idle' };
             }
+            if (!(await hasSchedulerCapacity(deps.clock.now()))) {
+                return { status: 'idle' };
+            }
             const runId = `run-${candidate.issue.number}-${deps.clock.now().getTime()}`;
             const lease = createRunLease({ clock: deps.clock, ownerInstanceId });
             const workerIdentity = currentProcessIdentity();
@@ -461,6 +506,9 @@ export function createTickRunner(deps) {
                 lease,
                 workerPid: workerIdentity.pid,
                 workerProcessStartedAt: workerIdentity.processStartedAt,
+                metadata: {
+                    sourceRevision,
+                },
             };
             await deps.stateStore.writeRunRecord(runningRecord);
             async function transitionRunLifecycle(lifecycle) {
@@ -489,6 +537,7 @@ export function createTickRunner(deps) {
                     action,
                     priorStage: candidate.wake.stage,
                     claimedStage,
+                    sourceRevision,
                 },
             });
             await deps.stateStore.appendEventEnvelope(claimedEvent);
@@ -768,6 +817,7 @@ export function createTickRunner(deps) {
                     executionOutcome: 'PROCESS_FAILED',
                     summary: err instanceof Error ? err.message : String(err),
                     metadata: {
+                        ...failedRecord.metadata,
                         failureClass: 'infra',
                     },
                 });

package/dist/src/version.js

@@ -124,4 +124,4 @@ export function resolveWakeVersion(options = {}) {
     }
     return '0.1.0-dev';
 }
-export const wakeVersion = "g18ca5a7";
+export const wakeVersion = "gd481d17";

package/package.json

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