@atolis-hq/wake 0.3.4 → 0.3.6

package/dist/src/activities/agent/agent-activity.js

@@ -97,6 +97,7 @@ async function buildUntrustedContext(workItemId, contextReader) {
         issueTitle: context.title,
         issueBody: context.body,
         comments: context.comments,
+        ...(context.pullRequest === undefined ? {} : { pullRequest: context.pullRequest }),
     };
 }
 function untrustedDataBlock(context) {
@@ -108,6 +109,7 @@ function untrustedDataBlock(context) {
         escapeUntrustedJson(JSON.stringify({
             issue: { title: context.issueTitle, body: context.issueBody },
             comments: context.comments,
+            ...(context.pullRequest === undefined ? {} : { pullRequest: context.pullRequest }),
         }, null, 2)),
         '</wake-untrusted-data>',
     ].join('\n');

package/dist/src/bootstrap/surface-cli-applications.js

@@ -620,7 +620,7 @@ function createSandboxEntrypointDependencies(root) {
                     resolve();
                 });
             });
-            const drained = drainProcessOutput(child, sink, (error) => {
+            const drained = drainProcessOutput(child, sink, (value) => process.stderr.write(value), (error) => {
                 process.stderr.write(`Wake detached start log failure: ${error instanceof Error ? error.message : String(error)}\n`);
             });
             const completion = closed.then(() => drained).then(() => closeStatus);

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 = "g96ae149";
+export const wakeVersion = "gd042cce";

package/dist/src/integrations/github/application/agent-context-reader.js

@@ -1,6 +1,8 @@
-import { ResourceCorrelationRole } from '../../../resources/index.js';
+import { PullRequestCheckState, } from '../../../activities/index.js';
+import { BuiltInResourceKind, ResourceCorrelationRole, } from '../../../resources/index.js';
 import { adapterId } from '../../contracts/identifiers.js';
 import { integrationStream } from '../../contracts/streams.js';
+import { boundedDiagnosticEvidence } from '../contracts/check-evidence.js';
 import { GitHubEventType, selectGitHubAdapterEvent } from '../contracts/events.js';
 import { createCommentHistoryReader } from './comment-history-reader.js';
 export function createGitHubAgentContextReader(journal, resources) {
@@ -11,6 +13,7 @@ export function createGitHubAgentContextReader(journal, resources) {
             return {
                 ...(await currentWorkItemContent(journal, resources, workItemId)),
                 comments,
+                ...pullRequestContextField(await currentPullRequestContext(journal, resources, workItemId)),
             };
         },
     };
@@ -28,6 +31,38 @@ async function currentWorkItemContent(journal, resources, workItemId) {
     return latestWorkObservedContent(await journal.readStream(integrationStream(adapter)), adapter, resource.externalKey.key);
 }
 const emptyWorkItemContent = { title: '', body: '' };
+async function currentPullRequestContext(journal, resources, workItemId) {
+    let current;
+    for (const correlation of await resources.correlationsForWork(workItemId)) {
+        const resource = await resources.get(correlation.resourceId);
+        if (resource?.kind !== BuiltInResourceKind.PullRequest)
+            continue;
+        const adapter = parseAdapterId(resource.externalKey.adapter);
+        if (adapter === null)
+            continue;
+        for (const event of await journal.readStream(integrationStream(adapter))) {
+            const observed = selectGitHubAdapterEvent(event);
+            if (!isCurrentPullRequestObservedEvent(observed, adapter, resource.externalKey.key))
+                continue;
+            if (current === undefined || event.globalPosition > current.position)
+                current = { context: pullRequestContext(observed.payload), position: event.globalPosition };
+        }
+    }
+    return current?.context;
+}
+function pullRequestContext(payload) {
+    return {
+        checks: payload.checks ?? PullRequestCheckState.Unknown,
+        checkRuns: rawEvidenceList(payload.raw.checkRuns),
+        statuses: rawEvidenceList(payload.raw.statuses),
+    };
+}
+function rawEvidenceList(value) {
+    return Array.isArray(value) ? boundedDiagnosticEvidence(value) : [];
+}
+function pullRequestContextField(context) {
+    return context === undefined ? {} : { pullRequest: context };
+}
 function latestWorkObservedContent(events, adapter, externalKey) {
     let current;
     for (const event of events) {
@@ -44,6 +79,10 @@ function isCurrentWorkObservedEvent(observed, adapter, externalKey) {
         observed.source.id === adapter &&
         observed.payload.externalKey === externalKey);
 }
+function isCurrentPullRequestObservedEvent(observed, adapter, externalKey) {
+    return (isCurrentWorkObservedEvent(observed, adapter, externalKey) &&
+        observed.payload.kind === 'pull-request');
+}
 function parseAdapterId(value) {
     try {
         return adapterId(value);

package/dist/src/integrations/github/application/wake-labels.js

@@ -20,6 +20,7 @@ export function createGitHubWakeLabelReconciler(input) {
         }
         return open;
     };
+    const onError = input.onError ?? defaultOnError;
     return {
         async runOnce() {
             const workflows = await input.orchestration.listAll();
@@ -49,15 +50,27 @@ export function createGitHubWakeLabelReconciler(input) {
                     const locator = parseGitHubIssueKey(resource.externalKey.key);
                     if (locator === null)
                         continue;
-                    const current = await input.getLabels(locator.owner, locator.repo, locator.number);
-                    const next = reconcileGitHubWakeLabels(current, desired);
-                    if (!sameLabels(current, next))
-                        await input.setLabels(locator.owner, locator.repo, locator.number, next);
+                    // One issue's persistent failure (rate limit, permissions, a stale
+                    // resource) must not stop every other open work item from being
+                    // reconciled this pass — each correlation is an independent GitHub
+                    // call with no ordering dependency on the others.
+                    try {
+                        const current = await input.getLabels(locator.owner, locator.repo, locator.number);
+                        const next = reconcileGitHubWakeLabels(current, desired);
+                        if (!sameLabels(current, next))
+                            await input.setLabels(locator.owner, locator.repo, locator.number, next);
+                    }
+                    catch (error) {
+                        onError({ workItemId: workflow.workItemId, ...locator }, error);
+                    }
                 }
             }
         },
     };
 }
+function defaultOnError(failure, error) {
+    process.stderr.write(`GitHub label reconcile failed for ${failure.owner}/${failure.repo}#${failure.number}: ${error instanceof Error ? error.message : String(error)}\n`);
+}
 function desiredWakeLabels(workflow, watching) {
     return [
         `wake:status.${statusLabel(workflow.status)}`,

package/dist/src/integrations/github/contracts/check-evidence.js

@@ -0,0 +1,37 @@
+const diagnosticKeys = [
+    'name',
+    'status',
+    'conclusion',
+    'started_at',
+    'completed_at',
+    'details_url',
+    'html_url',
+    'context',
+    'state',
+    'target_url',
+];
+const maxEvidenceEntries = 20;
+const maxEvidenceBytes = 12_000;
+export function boundedDiagnosticEvidence(evidence) {
+    const bounded = [];
+    let bytes = 0;
+    for (const value of evidence) {
+        if (bounded.length === maxEvidenceEntries)
+            break;
+        if (!isRecord(value))
+            continue;
+        const diagnostic = diagnosticEvidence(value);
+        const entryBytes = Buffer.byteLength(JSON.stringify(diagnostic), 'utf8');
+        if (bytes + entryBytes > maxEvidenceBytes)
+            break;
+        bounded.push(diagnostic);
+        bytes += entryBytes;
+    }
+    return bounded;
+}
+function diagnosticEvidence(entry) {
+    return Object.fromEntries(diagnosticKeys.flatMap((key) => typeof entry[key] === 'string' || entry[key] === null ? [[key, entry[key]]] : []));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

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

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { PullRequestCheckState, PullRequestState, ReviewActorKind, } from '../../../activities/index.js';
 import { createEventDraft, EventActorKind, EventSourceKind } from '../../../kernel/index.js';
 import { integrationStream } from '../../contracts/streams.js';
+import { boundedDiagnosticEvidence } from '../contracts/check-evidence.js';
 import { GitHubEventType } from '../contracts/events.js';
 import { formatGitHubResourceKey } from '../contracts/external-key.js';
 import { gitHubAssigneeLogins, gitHubLabelNames, } from '../contracts/payloads.js';
@@ -53,7 +54,11 @@ function pullRequestObservation(input) {
         },
         labels: gitHubLabelNames(pullRequest),
         assignees: gitHubAssigneeLogins(pullRequest),
-        raw: { number: pullRequest.number },
+        raw: {
+            number: pullRequest.number,
+            checkRuns: boundedDiagnosticEvidence(input.evidence.checkRuns),
+            statuses: boundedDiagnosticEvidence(input.evidence.statuses),
+        },
     };
     const fingerprint = evidenceFingerprint(payload, input.evidence);
     return createEventDraft({

package/dist/src/orchestration/application/advance-workflow.js

@@ -1,3 +1,4 @@
+import { ActivityEventType, PullRequestCheckState, selectActivityEvent, } from '../../activities/index.js';
 import { EventSourceKind, createEventDraft } from '../../kernel/index.js';
 import { OrchestrationEventType } from '../contracts/events.js';
 import { commandName, workflowInstanceId, } from '../contracts/identifiers.js';
@@ -147,14 +148,22 @@ export class AdvanceWorkflow {
     async listAll() {
         return (await this.repository.list()).filter((view) => view !== null);
     }
-    async listWatchMatches(eventType) {
+    async listWatchMatches(event) {
         return (await this.listAll()).flatMap((parent) => {
             const definition = this.workflows.definition(parent.workflowName);
             return definition.watches
-                .filter((watch) => watch.on?.events.includes(eventType) === true &&
+                .filter((watch) => watch.on?.events.includes(event.eventType) === true &&
                 watch.while.stages.includes(parent.currentStage) &&
-                watch.while.statuses.some((status) => status === parent.status))
+                watch.while.statuses.some((status) => status === parent.status) &&
+                matchesWatchPredicate(watch.where, event))
                 .map((watch) => ({ parent, watch }));
         });
     }
 }
+function matchesWatchPredicate(predicate, event) {
+    if (predicate === undefined)
+        return true;
+    const activityEvent = selectActivityEvent(event);
+    return (activityEvent?.eventType === ActivityEventType.PrChecksChanged &&
+        activityEvent.payload.checks === PullRequestCheckState.Failing);
+}

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

@@ -75,8 +75,8 @@ export class OrchestrationService {
     isCausalRepeat(workflowInstanceId, triggerId, causalCycleId, requestId) {
         return this.childWorkflows.isCausalRepeat(workflowInstanceId, triggerId, causalCycleId, requestId);
     }
-    listWatchMatches(eventType) {
-        return this.advanceWorkflow.listWatchMatches(eventType);
+    listWatchMatches(event) {
+        return this.advanceWorkflow.listWatchMatches(event);
     }
 }
 export const createOrchestrationService = (journal, work, definitions) => new OrchestrationService(journal, work, definitions);

package/dist/src/orchestration/application/watch-reactor.js

@@ -8,7 +8,7 @@ export function createWatchReactor(orchestration, journal, checkpoints, runs) {
         async react(event, context) {
             const causalCycle = orchestrationCausalCycleId(selectOrchestrationEvent(event));
             const sourceWorkflowInstanceId = await resolveRunWorkflowInstanceId(event, runs);
-            for (const match of await orchestration.listWatchMatches(event.eventType)) {
+            for (const match of await orchestration.listWatchMatches(event)) {
                 if (sourceWorkflowInstanceId !== undefined &&
                     match.parent.workflowInstanceId !== sourceWorkflowInstanceId)
                     continue;

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

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { ApprovalAuthorityKind, WorkflowStatus } from './vocabulary.js';
+import { PullRequestCheckState } from '../../activities/index.js';
 import { WorkspaceMode } from '../../execution/index.js';
 import { MatchMode } from '../../kernel/index.js';
 const identifier = z.string().trim().min(1);
@@ -33,6 +34,9 @@ const watchGateConfigSchema = z.union([
 const commandName = z.string().regex(/^\/[a-z][a-z0-9-]*$/);
 const canonicalEventName = z.string().regex(/^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)+$/);
 const watchStatus = z.enum([WorkflowStatus.Active, WorkflowStatus.Waiting, WorkflowStatus.Blocked]);
+const failingChecksWatchPredicateSchema = z
+    .object({ checks: z.literal(PullRequestCheckState.Failing) })
+    .strict();
 export const watchConfigSchema = z
     .object({
     id: identifier,
@@ -46,6 +50,7 @@ export const watchConfigSchema = z
         .object({ events: z.array(canonicalEventName).min(1).readonly() })
         .strict()
         .optional(),
+    where: failingChecksWatchPredicateSchema.optional(),
     schedule: z.object({ cron: identifier }).strict().optional(),
     workflow: identifier,
     maxPerGroup: z.number().int().positive(),

package/dist/src/orchestration/domain/compiler.js

@@ -1,4 +1,4 @@
-import { activityName, ActivityOutcomeKind, } from '../../activities/index.js';
+import { ActivityEventType, activityName, ActivityOutcomeKind, } from '../../activities/index.js';
 import { workflowDefinitionConfigSchema, } from '../contracts/config.js';
 import { commandName, signalName, stageName, watchId, workflowName, } from '../contracts/identifiers.js';
 import { ApprovalAuthorityKind, TransitionTargetKind } from '../contracts/vocabulary.js';
@@ -42,6 +42,10 @@ function compileWatches(config, stageNames, knownWorkflowNames) {
             throw new Error(`Unknown watch stage: ${unknownStages.join(', ')}`);
         if (!knownWorkflowNames.includes(watch.workflow))
             throw new Error(`Unknown watch workflow: ${watch.workflow}`);
+        if (watch.where !== undefined &&
+            (watch.on === undefined ||
+                watch.on.events.some((event) => event !== ActivityEventType.PrChecksChanged)))
+            throw new Error('Watch where.checks is only valid with pr.checks-changed');
         return Object.freeze({
             ...watch,
             id: watchId(watch.id),

package/dist/src/surfaces/cli/infrastructure/process-log.js

@@ -41,8 +41,14 @@ export function createProcessLogSink(path, output, options = {}) {
  * Serializes detached child output into a sink and resolves only after Node's
  * `close` event confirms its stdio streams have closed. Sink failures are
  * reported rather than becoming detached, unhandled promise rejections.
+ *
+ * The child's full stdout+stderr always reaches the sink (durable file), but
+ * only stderr is also handed to `onStderr` — the child already writes its
+ * actionable failures there (GitHub request failures, tick failures) and
+ * routine detail to stdout, so this lets a detached supervisor surface just
+ * the actionable half on its own stderr without re-deriving severity here.
  */
-export function drainProcessOutput(process, sink, reportError) {
+export function drainProcessOutput(process, sink, onStderr, reportError) {
     let writes = Promise.resolve();
     const report = (error) => {
         try {
@@ -52,12 +58,18 @@ export function drainProcessOutput(process, sink, reportError) {
             // A reporting failure must not make a detached child unhandled.
         }
     };
-    const enqueue = (chunk) => {
+    const enqueue = (chunk, escalate) => {
         const value = chunk.toString();
-        writes = writes.then(() => sink.write(value)).catch(report);
+        writes = writes
+            .then(() => sink.write(value))
+            .then(() => {
+            if (escalate)
+                onStderr(scrubProcessLog(value));
+        })
+            .catch(report);
     };
-    process.stdout?.on('data', enqueue);
-    process.stderr?.on('data', enqueue);
+    process.stdout?.on('data', (chunk) => enqueue(chunk, false));
+    process.stderr?.on('data', (chunk) => enqueue(chunk, true));
     process.on('error', report);
     return new Promise((resolve) => {
         process.once('close', () => {

package/package.json

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