@atolis-hq/wake 0.4.40 → 0.4.42

package/dist/src/bootstrap/composition-root.js

@@ -127,7 +127,10 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
             : createTranscriptRetention(transcriptStore, projections, config, clock)),
         runnerIneligibility: createDurableRunnerIneligibility(journal, () => clock.now().toISOString()),
     });
-    const advanceOnce = activationScheduler.runOnce.bind(activationScheduler);
+    const advanceOnce = Object.assign(activationScheduler.runOnce.bind(activationScheduler), {
+        maintain: activationScheduler.maintain.bind(activationScheduler),
+        dispatch: activationScheduler.dispatch.bind(activationScheduler),
+    });
     const activationSchedulerSubscriber = createActivationSchedulerSubscriber(activationScheduler);
     const runtime = await composeIntegrationRuntime({
         config,

package/dist/src/bootstrap/version.js

@@ -124,6 +124,6 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "v0.4.40";
+export const wakeVersion = "v0.4.42";
 /** The registry-installable version used by packaged sandbox images. */
 export const wakePackageVersion = packageVersion(defaultRepoRoot) ?? wakeVersion;

package/dist/src/control-plane/application/activation-scheduler.d.ts

@@ -1,8 +1,11 @@
 import { type Clock } from '../../kernel/index.js';
 import type { ResourceService } from '../../resources/index.js';
+import type { MaintenanceResult } from '../contracts/commands.js';
 import type { AdvanceOptions, AdvanceResult } from '../contracts/views.js';
 import type { ActivationSchedulerDependencies, ExecutionPort, OrchestrationPort } from './activation-scheduler-ports.js';
 export interface ActivationScheduler {
     runOnce(options: AdvanceOptions, signal?: AbortSignal): Promise<AdvanceResult>;
+    maintain?(signal?: AbortSignal): Promise<MaintenanceResult>;
+    dispatch?(options: AdvanceOptions, signal?: AbortSignal): Promise<AdvanceResult>;
 }
 export declare function createActivationScheduler(orchestration: OrchestrationPort, execution: ExecutionPort, resources: ResourceService, clock: Clock, dependencies: ActivationSchedulerDependencies): ActivationScheduler;

package/dist/src/control-plane/application/activation-scheduler.js

@@ -21,9 +21,7 @@ export function createActivationScheduler(orchestration, execution, resources, c
         occurredAt: clock.now().toISOString(),
         actor: { kind: EventActorKind.System, id: ControlStreamKind.Global },
     });
-    const run = async (options) => {
-        if (options.maxProgress < 1)
-            return { kind: 'exhausted', progressCount: 0 };
+    const maintain = async () => {
         if (await isDispatchPaused())
             return { kind: 'paused' };
         if (workspaceRecovery !== undefined) {
@@ -76,6 +74,13 @@ export function createActivationScheduler(orchestration, execution, resources, c
         if (await isDispatchPaused())
             return { kind: 'paused' };
         await orchestration.reconcileChildCompletions(context('child-completion-reconciliation'));
+        if (await isDispatchPaused())
+            return { kind: 'paused' };
+        return { kind: 'ready' };
+    };
+    const dispatch = async (options) => {
+        if (options.maxProgress < 1)
+            return { kind: 'exhausted', progressCount: 0 };
         if (await isDispatchPaused())
             return { kind: 'paused' };
         const rawPending = await orchestration.listPendingActivations(options.workItemId);
@@ -146,7 +151,16 @@ export function createActivationScheduler(orchestration, execution, resources, c
         });
     };
     const serialise = dependencies.schedulerSerialiser ?? createInProcessSerialiser();
-    return { runOnce: (options, signal) => serialise(() => run(options), signal) };
+    return {
+        runOnce: (options, signal) => serialise(async () => {
+            if (options.maxProgress < 1)
+                return { kind: 'exhausted', progressCount: 0 };
+            const maintenance = await maintain();
+            return maintenance.kind === 'paused' ? { kind: 'paused' } : dispatch(options);
+        }, signal),
+        maintain: (signal) => serialise(maintain, signal),
+        dispatch: (options, signal) => serialise(() => dispatch(options), signal),
+    };
 }
 function createInProcessSerialiser() {
     let prior = Promise.resolve();

package/dist/src/control-plane/application/advance-once-dispatch.js

@@ -40,6 +40,10 @@ export async function runDispatchLoop(pending, ctx) {
     let stopReason;
     while (dispatched.length < ctx.maxDispatches) {
         const allRuns = await ctx.execution.list();
+        const activeActivationIds = new Set(allRuns.filter((run) => isActiveRunStatus(run.status)).map((run) => run.activationId));
+        const branchActiveWorkflowIds = new Set(allRuns
+            .filter((run) => isActiveRunStatus(run.status) && run.workspace?.mode === WorkspaceMode.Branch)
+            .map((run) => run.workflowInstanceId));
         if (allRuns.filter((run) => isActiveRunStatus(run.status)).length >= ctx.maxConcurrentRuns) {
             stopReason = { kind: 'no-work' };
             break;
@@ -49,10 +53,8 @@ export async function runDispatchLoop(pending, ctx) {
             activationId: item.activation.activationId,
             requestedPosition,
             hasActiveRun: dispatchedIds.has(item.activation.activationId) ||
-                (await ctx.execution.list(item.activation.activationId)).some((run) => isActiveRunStatus(run.status)) ||
-                allRuns.some((run) => isActiveRunStatus(run.status) &&
-                    run.workflowInstanceId === item.workflow.workflowInstanceId &&
-                    run.workspace?.mode === WorkspaceMode.Branch),
+                activeActivationIds.has(item.activation.activationId) ||
+                branchActiveWorkflowIds.has(item.workflow.workflowInstanceId),
             cancelled: false,
         }))))[0];
         const selected = selectedCandidate === undefined

package/dist/src/control-plane/application/advance-once.d.ts

@@ -2,4 +2,7 @@ import type { Clock } from '../../kernel/index.js';
 import type { ResourceService } from '../../resources/index.js';
 import type { ActivationSchedulerDependencies, ExecutionPort, OrchestrationPort } from './activation-scheduler-ports.js';
 /** Compatibility facade for callers that still use the former Advancement name. */
-export declare function createAdvanceOnce(orchestration: OrchestrationPort, execution: ExecutionPort, resources: ResourceService, clock: Clock, dependencies: ActivationSchedulerDependencies): (options: Parameters<(options: import("../index.js").AdvanceOptions, signal?: AbortSignal) => Promise<import("../index.js").AdvanceResult>>[0]) => Promise<import("../index.js").AdvanceResult>;
+export declare function createAdvanceOnce(orchestration: OrchestrationPort, execution: ExecutionPort, resources: ResourceService, clock: Clock, dependencies: ActivationSchedulerDependencies): ((options: import("../index.js").AdvanceOptions, signal?: AbortSignal) => Promise<import("../index.js").AdvanceResult>) & {
+    maintain: (signal?: AbortSignal) => Promise<import("../contracts/commands.js").MaintenanceResult>;
+    dispatch: (options: import("../index.js").AdvanceOptions, signal?: AbortSignal) => Promise<import("../index.js").AdvanceResult>;
+};

package/dist/src/control-plane/application/advance-once.js

@@ -2,5 +2,8 @@ import { createActivationScheduler } from './activation-scheduler.js';
 /** Compatibility facade for callers that still use the former Advancement name. */
 export function createAdvanceOnce(orchestration, execution, resources, clock, dependencies) {
     const scheduler = createActivationScheduler(orchestration, execution, resources, clock, dependencies);
-    return (options) => scheduler.runOnce(options);
+    return Object.assign(scheduler.runOnce.bind(scheduler), {
+        maintain: scheduler.maintain.bind(scheduler),
+        dispatch: scheduler.dispatch.bind(scheduler),
+    });
 }

package/dist/src/control-plane/contracts/commands.d.ts

@@ -18,3 +18,12 @@ export interface HostResult {
     readonly stoppedBecause: 'idle' | typeof HostStopReason.Waiting | typeof HostStopReason.Blocked | 'budget' | 'paused' | typeof HostStopReason.Shutdown;
 }
 export type AdvanceOnce = (options: AdvanceOptions, signal?: AbortSignal) => Promise<AdvanceResult>;
+/** Optional scheduler phases used by hosts that can make several dispatch attempts in one pass. */
+export interface AdvancePhases {
+    maintain(signal?: AbortSignal): Promise<MaintenanceResult>;
+    dispatch(options: AdvanceOptions, signal?: AbortSignal): Promise<AdvanceResult>;
+}
+export type MaintenanceResult = {
+    readonly kind: 'ready' | 'paused';
+};
+export type PhasedAdvanceOnce = AdvanceOnce & Partial<AdvancePhases>;

package/dist/src/control-plane/infrastructure/tick-host.d.ts

@@ -1,6 +1,6 @@
-import { type AdvanceOnce, type HostBudget, type HostResult } from '../contracts/commands.js';
+import { type HostBudget, type HostResult, type PhasedAdvanceOnce } from '../contracts/commands.js';
 export declare class TickHost {
     private readonly advance;
-    constructor(advance: AdvanceOnce);
+    constructor(advance: PhasedAdvanceOnce);
     run(budget: HostBudget, signal?: AbortSignal): Promise<HostResult>;
 }

package/dist/src/control-plane/infrastructure/tick-host.js

@@ -9,10 +9,14 @@ export class TickHost {
         const started = Date.now();
         let advances = 0;
         let runs = 0;
+        const preparation = await prepareDispatch(this.advance, budget, started, signal);
+        if (preparation !== undefined)
+            return preparation;
+        const dispatch = this.advance.dispatch;
         while (advances < budget.maxAdvances && runs < budget.maxRuns) {
             if (Date.now() - started >= budget.maxDurationMs)
                 return { advances, runs, stoppedBecause: HostStopReason.Budget };
-            const result = await this.advance({ maxProgress: 1 }, signal);
+            const result = await (dispatch ?? this.advance)({ maxProgress: 1 }, signal);
             if (result.kind === 'progressed') {
                 advances += 1;
                 runs += result.dispatched.length;
@@ -33,3 +37,12 @@ export class TickHost {
         return { advances, runs, stoppedBecause: HostStopReason.Budget };
     }
 }
+async function prepareDispatch(advance, budget, started, signal) {
+    if (advance.dispatch === undefined || advance.maintain === undefined || budget.maxAdvances < 1)
+        return undefined;
+    if (Date.now() - started >= budget.maxDurationMs)
+        return { advances: 0, runs: 0, stoppedBecause: HostStopReason.Budget };
+    return (await advance.maintain(signal)).kind === 'paused'
+        ? { advances: 0, runs: 0, stoppedBecause: HostStopReason.Paused }
+        : undefined;
+}

package/dist/src/integrations/github/application/inbound-watch-gate-signals.js

@@ -35,9 +35,7 @@ function extractMarker(body) {
 function translateOutcome(outcome) {
     if (outcome === 'DONE')
         return ActivityOutcomeKind.Done;
-    if (outcome === 'REJECTED')
-        return ActivityOutcomeKind.Rejected;
-    return null;
+    return ActivityOutcomeKind.Rejected;
 }
 export async function applyWatchGateVerdictSignal(input) {
     const { event, runs, orchestration } = input;
@@ -47,8 +45,6 @@ export async function applyWatchGateVerdictSignal(input) {
     if (marker === null)
         return;
     const outcome = translateOutcome(marker.outcome);
-    if (outcome === null)
-        return;
     const verdict = await verifyWatchGateVerdict({ marker, outcome, runs, orchestration });
     if (verdict === null)
         return;
@@ -66,7 +62,9 @@ async function verifyWatchGateVerdict(input) {
     const run = (await runs.load(runId(marker.runId))).view;
     if (run === null)
         return null;
-    if (run.status !== RunStatus.Succeeded || run.outcome?.kind !== outcome)
+    if (run.status !== RunStatus.Succeeded ||
+        run.outcome === undefined ||
+        translateOutcome(run.outcome.kind.toUpperCase()) !== outcome)
         return null;
     const workflows = await orchestration.listAll();
     const child = workflows.find((workflow) => workflow.workflowInstanceId === run.workflowInstanceId);

package/dist/src/integrations/github/infrastructure/client-reads.d.ts

@@ -3,6 +3,7 @@ import { PullRequestState } from '../../../activities/index.js';
 import type { GitHubIssueQueryFilters } from '../contracts/issue-query.js';
 import type { GitHubIssueCommentPayload, GitHubIssuePayload } from '../contracts/payloads.js';
 import type { createEtagCache } from './etag-cache.js';
+export declare function findIssueCommentByMarker(octokit: Octokit, owner: string, repo: string, issueNumber: number, marker: string): Promise<string | null>;
 export declare function listIssues(octokit: Octokit, cache: ReturnType<typeof createEtagCache>, owner: string, repo: string, maxResults: number, options?: {
     readonly since?: string;
     readonly filters?: GitHubIssueQueryFilters;

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

@@ -2,6 +2,22 @@
 import { PullRequestState } from '../../../activities/index.js';
 import { GitHubListState } from '../contracts/vocabulary.js';
 import { fetchPaginatedWithEtag, fetchWithEtag } from './etag-cache.js';
+export async function findIssueCommentByMarker(octokit, owner, repo, issueNumber, marker) {
+    for await (const page of octokit.paginate.iterator(octokit.rest.issues.listComments, {
+        owner,
+        repo,
+        issue_number: issueNumber,
+        per_page: 100,
+    })) {
+        const comment = page.data.find((value) => value.body?.includes(marker));
+        if (comment !== undefined) {
+            if (!Number.isSafeInteger(comment.id) || comment.id <= 0)
+                throw new Error('GitHub comment marker lookup returned an invalid comment id');
+            return String(comment.id);
+        }
+    }
+    return null;
+}
 export function listIssues(octokit, cache, owner, repo, maxResults, options = {}) {
     const { since, filters = {} } = options;
     return fetchPaginatedWithEtag({

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

@@ -2,8 +2,9 @@ import { Octokit } from '@octokit/rest';
 import { MergeMethod, ProviderPermission, PullRequestState } from '../../../activities/index.js';
 import { GitHubOutboundAction } from '../contracts/vocabulary.js';
 import { createBoundedGitHubFetch } from './bounded-fetch.js';
-import { branch, getCombinedStatusForRef, getIssueLabels, getPullRequest, listCheckRunsForRef, listIssueComments, listIssues, listPullRequestFiles, listPullRequests, listReviewComments, listReviews, } from './client-reads.js';
+import { branch, findIssueCommentByMarker, getCombinedStatusForRef, getIssueLabels, getPullRequest, listCheckRunsForRef, listIssueComments, listIssues, listPullRequestFiles, listPullRequests, listReviewComments, listReviews, } from './client-reads.js';
 import { createEtagCache } from './etag-cache.js';
+/* eslint-disable max-lines */
 // Octokit's request-log plugin reports every non-2xx response through this
 // callback, including the expected 304 responses produced by conditional ETag
 // reads. Keep those cache hits quiet, but retain a small, safe operator signal
@@ -169,6 +170,9 @@ async function deliver(octokit, command) {
     const issueNumber = command.issue_number ?? command.pull_number;
     if (issueNumber === undefined)
         throw new Error('GitHub comment requires an issue or pull request');
+    const existingCommentId = await findIssueCommentByMarker(octokit, command.owner, command.repo, issueNumber, marker);
+    if (existingCommentId !== null)
+        return existingCommentId;
     const response = await octokit.rest.issues.createComment({
         owner: command.owner,
         repo: command.repo,

package/dist/src/orchestration/application/request-child.js

@@ -177,8 +177,7 @@ function watchIdsFor(wait) {
 function watchGateVerdictOutcome(parent, child) {
     if (parent.waitingFor?.signalKind !== WatchGateVerdictSignal)
         return undefined;
-    return child.lastOutcome?.kind === ActivityOutcomeKind.Done ||
-        child.lastOutcome?.kind === ActivityOutcomeKind.Rejected
-        ? child.lastOutcome.kind
-        : undefined;
+    return child.lastOutcome?.kind === ActivityOutcomeKind.Done
+        ? ActivityOutcomeKind.Done
+        : ActivityOutcomeKind.Rejected;
 }

package/package.json

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