@atolis-hq/wake 0.3.84 → 0.3.86

package/dist/src/bootstrap/board-projection.js

@@ -93,33 +93,38 @@ function projectWork(view, event, occurredAt) {
     return view;
 }
 function projectWorkflow(view, event, occurredAt) {
-    if (event.eventType === OrchestrationEventType.InstanceStarted) {
-        const workId = event.payload.workItemId;
-        const card = view.cards[workId];
-        if (card === undefined)
-            return view;
-        const workflows = { ...view.workflows, [event.stream.id]: workId };
-        if ('parentWorkflowInstanceId' in event.payload)
-            return {
-                ...view,
-                workflows,
-                children: { ...view.children, [event.stream.id]: event.payload.entry },
-            };
+    if (event.eventType === OrchestrationEventType.InstanceStarted)
+        return projectWorkflowStarted(view, event, occurredAt);
+    return projectWorkflowUpdate(view, event, occurredAt);
+}
+function projectWorkflowStarted(view, event, occurredAt) {
+    const workId = event.payload.workItemId;
+    const card = view.cards[workId];
+    if (card === undefined)
+        return view;
+    const workflows = { ...view.workflows, [event.stream.id]: workId };
+    if ('parentWorkflowInstanceId' in event.payload)
         return {
             ...view,
-            cards: {
-                ...view.cards,
-                [workId]: {
-                    ...card,
-                    workflowName: event.payload.workflowName,
-                    stage: event.payload.entry,
-                    dwellSince: occurredAt,
-                    condition: BoardCondition.Ready,
-                },
-            },
             workflows,
+            children: { ...view.children, [event.stream.id]: event.payload.entry },
         };
-    }
+    return {
+        ...view,
+        cards: {
+            ...view.cards,
+            [workId]: {
+                ...card,
+                workflowName: event.payload.workflowName,
+                stage: event.payload.entry,
+                dwellSince: occurredAt,
+                condition: BoardCondition.Ready,
+            },
+        },
+        workflows,
+    };
+}
+function projectWorkflowUpdate(view, event, occurredAt) {
     if (view.children?.[event.stream.id] !== undefined)
         return view;
     const located = lookupWorkflowCard(view, event.stream.id);
@@ -142,7 +147,7 @@ function projectWorkflow(view, event, occurredAt) {
             cards: {
                 ...view.cards,
                 [workId]: {
-                    ...card,
+                    ...withoutBlockReason(card),
                     stage: event.payload.stage,
                     dwellSince: occurredAt,
                     condition: BoardCondition.Ready,
@@ -158,7 +163,15 @@ function projectWorkflow(view, event, occurredAt) {
     const status = orchestrationStatusTransitions[event.eventType];
     if (status === undefined)
         return view;
-    const withCondition = { ...card, condition: boardConditionForStatus(status) };
+    const withCondition = {
+        ...(event.eventType === OrchestrationEventType.InstanceBlocked
+            ? card
+            : withoutBlockReason(card)),
+        condition: boardConditionForStatus(status),
+        ...(event.eventType === OrchestrationEventType.InstanceBlocked
+            ? { blockReason: event.payload.reason }
+            : {}),
+    };
     if (event.eventType === OrchestrationEventType.SignalWaitStarted)
         return {
             ...view,
@@ -196,6 +209,10 @@ function lookupWorkflowCard(view, streamId) {
 function awaitingApprovalField(signalKind) {
     return isApprovalAwaitingSignalKind(signalKind) ? { awaitingApproval: true } : {};
 }
+function withoutBlockReason(card) {
+    const { blockReason: _blockReason, ...withoutReason } = card;
+    return withoutReason;
+}
 const runTerminalEventTypes = new Set([
     ExecutionEventType.RunSucceeded,
     ExecutionEventType.RunFailed,

package/dist/src/bootstrap/self-update-failure-log.js

@@ -1,5 +1,13 @@
 import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
+// recordUpdateFailure (self-update-application.ts) records every failed
+// attempt through this same log regardless of stage — including one that
+// never reached rollout.deploy() at all, e.g. a quiesce timeout waiting on
+// active Runs. "rolled back" would misreport those as a completed deploy
+// that had to be undone, when nothing was ever deployed.
+export function describeSelfUpdateFailure(failure) {
+    return `update to ${failure.tag} failed at ${failure.occurredAt}: ${failure.message}`;
+}
 /**
  * Persists the most recent self-update rollback so it can surface on the
  * operator health screen instead of relying on a third-party notification —

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

@@ -3,7 +3,7 @@ import { ApiCommandStatus, fromWorkItemKey, presentBoardCard, presentResource, p
 import { analyticsProjection } from './analytics-projection.js';
 import { boardConditionCounts, boardProjection, } from './board-projection.js';
 import { primaryExternalRef } from './external-ref.js';
-import { createSelfUpdateFailureLog } from './self-update-failure-log.js';
+import { createSelfUpdateFailureLog, describeSelfUpdateFailure, } from './self-update-failure-log.js';
 import { createExecutionApplications } from './surface-api-execution-applications.js';
 import { projectionMeta, sampledMeta } from './surface-api-metadata.js';
 import { projectionPage } from './surface-api-projection-pages.js';
@@ -200,7 +200,7 @@ function createSystemApplications(root, now) {
                     : {
                         name: 'self-update',
                         status: 'degraded',
-                        detail: `rolled back from ${selfUpdateFailure.tag} at ${selfUpdateFailure.occurredAt}: ${selfUpdateFailure.message}`,
+                        detail: describeSelfUpdateFailure(selfUpdateFailure),
                     },
             ];
             const adapters = root.providers.flatMap((instance) => (instance.health?.() ?? []).map((check) => ({
@@ -309,15 +309,25 @@ async function performTick(root, now, command, sequence) {
         result: await readControlPlaneStatus(root, now),
     };
 }
-async function readControlPlaneStatus(root, now) {
+export async function readControlPlaneStatus(root, now) {
     const stored = await root.projections.read(ControlStreamKind.Global, 'global');
     const meta = await projectionMeta(root.journal, stored === null ? [] : [stored], now());
+    const lease = await root.maintenance.read();
     return {
         data: {
             paused: stored?.value.pausedUntil !== null && stored?.value.pausedUntil !== undefined,
             ...(stored?.value.pausedUntil == null ? {} : { pausedUntil: stored.value.pausedUntil }),
             ...(stored?.value.reason === undefined ? {} : { reason: stored.value.reason }),
             updatedAt: meta.asOf,
+            ...(lease === null
+                ? {}
+                : {
+                    maintenanceLease: {
+                        phase: lease.phase,
+                        startedAt: lease.startedAt,
+                        ...(lease.failure === undefined ? {} : { failure: lease.failure }),
+                    },
+                }),
         },
         meta,
     };

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

@@ -9,7 +9,7 @@ import { IntakeHost, ResidentHost, TickHost } from '../control-plane/index.js';
 import { ExecutionCancellationReason, ExecutionFailureCode, RunStatus, loadPromptTemplate, } from '../execution/index.js';
 import { EventActorKind, correlationId } from '../kernel/index.js';
 import { ResourceCorrelationRole, resourceId } from '../resources/index.js';
-import { DockerProcessError, createApiDispatcher, createApiHttpServer, createLoggedDockerCli, createPackagedAssetSource, createProcessLogSink, createSandboxDockerPort, drainProcessOutput, runDoctor, runSandbox, runSandboxEntrypoint, runSandboxSetup, runSelfUpdateLatestLoop, runTargetSmoke, verifyResidentStart, waitForActiveRuns, } from '../surfaces/index.js';
+import { DockerProcessError, createApiDispatcher, createApiHttpServer, createLoggedDockerCli, createPackagedAssetSource, createProcessLogSink, createSandboxDockerPort, drainProcessOutput, runDoctor, runSandbox, runSandboxEntrypoint, runSandboxSetup, runSelfUpdateLatestLoop, runTargetSmoke, verifyResidentStart, waitForActiveRuns, waitForever, } from '../surfaces/index.js';
 import { WorkStreamKind, workItemId } from '../work/index.js';
 import { loadConfig } from './config/load-config.js';
 import { runtimeProjectionDefinitions } from './projection-runtime.js';
@@ -456,6 +456,7 @@ async function doctorDiagnostics(root) {
         }
     }
     await checkProviders(root, failures, notices);
+    await checkMaintenanceLease(root, failures);
     notices.push(...(await dockerSandboxHealthNotices(root)));
     for (const [name, path] of Object.entries({
         events: root.paths.eventsRoot,
@@ -490,6 +491,21 @@ function referencedPromptTemplateNames(workflows) {
     }
     return [...names];
 }
+// A retained maintenance lease pauses every resident loop (intake and
+// dispatch) regardless of phase -- including Failed, since it's the
+// operator's decision whether a failed attempt is safe to retry or clear.
+// Without this check the pause is invisible: the process ticks normally and
+// logs nothing, so a stuck lease from an update that couldn't quiesce active
+// Runs looks identical to a healthy idle system.
+async function checkMaintenanceLease(root, failures) {
+    const lease = await root.maintenance.read();
+    if (lease === null)
+        return;
+    const detail = lease.failure === undefined ? '' : ` (${lease.failure})`;
+    failures.push(`update maintenance lease is held in phase "${lease.phase}" since ${lease.startedAt}${detail} -- ` +
+        'every resident loop stays paused until it is cleared or resumes; run `wake self-update` ' +
+        'to retry, or clear the lease manually if the attempt is abandoned');
+}
 async function checkProviders(root, failures, notices) {
     for (const provider of root.providers) {
         if (provider.adapter.trim().length === 0) {
@@ -661,7 +677,7 @@ function createSandboxEntrypointDependencies(root) {
         waitForExit: async (pid) => children.get(pid) ?? 1,
         writeFile: (path, content) => writeFileContent(path, content, 'utf8'),
         sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
-        waitForever: () => new Promise(() => { }),
+        waitForever,
         log: (message) => process.stdout.write(`${message}\n`),
     };
 }

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 = "g80c78a2";
+export const wakeVersion = "g7341a7f";

package/dist/src/integrations/github/application/intake-policy.js

@@ -14,6 +14,29 @@ export function gitHubIntakeRules(configured) {
         tags: rule.tags,
     }));
 }
+// Rules are OR-composed. A native facet filter is safe only when every rule
+// requires the same single value; otherwise it could hide an item another rule admits.
+export function gitHubIssueQueryFilters(configured) {
+    const assignee = sharedRequiredValue(configured, (rule) => rule.where.requiredAssignees);
+    const labels = sharedRequiredValue(configured, (rule) => rule.where.labels);
+    return {
+        ...(assignee === undefined ? {} : { assignee }),
+        ...(labels === undefined ? {} : { labels }),
+    };
+}
+function sharedRequiredValue(configured, values) {
+    if (configured.length === 0)
+        return undefined;
+    const candidate = [...new Set(values(configured[0]))];
+    if (candidate.length !== 1)
+        return undefined;
+    return configured.every((rule) => {
+        const required = new Set(values(rule));
+        return required.size === 1 && required.has(candidate[0]);
+    })
+        ? candidate[0]
+        : undefined;
+}
 export function gitHubIntakeFacts(payload) {
     return {
         [GitHubIntakeFacet.Kind]: [payload.kind],

package/dist/src/integrations/github/contracts/issue-query.js

@@ -0,0 +1 @@
+export {};

package/dist/src/integrations/github/index.js

@@ -19,6 +19,7 @@ export * from './application/review-command-translator.js';
 export * from './application/wake-labels.js';
 export * from './contracts/config.js';
 export * from './contracts/events.js';
+export * from './contracts/issue-query.js';
 export * from './contracts/payloads.js';
 export * from './contracts/vocabulary.js';
 export * from './infrastructure/client.js';

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

@@ -2,10 +2,11 @@
 import { PullRequestState } from '../../../activities/index.js';
 import { GitHubListState } from '../contracts/vocabulary.js';
 import { fetchPaginatedWithEtag, fetchWithEtag } from './etag-cache.js';
-export function listIssues(octokit, cache, owner, repo, maxResults, since) {
+export function listIssues(octokit, cache, owner, repo, maxResults, options = {}) {
+    const { since, filters = {} } = options;
     return fetchPaginatedWithEtag({
         cache,
-        key: `issues:${owner}/${repo}:since:${since ?? 'bootstrap'}`,
+        key: `issues:${JSON.stringify([owner, repo, since ?? null, filters.assignee ?? null, filters.labels ?? null])}`,
         maxResults,
         pages: (headers) => octokit.paginate.iterator(octokit.rest.issues.listForRepo, {
             owner,
@@ -15,6 +16,8 @@ export function listIssues(octokit, cache, owner, repo, maxResults, since) {
             direction: 'desc',
             per_page: Math.min(maxResults, 100),
             ...(since === undefined ? {} : { since }),
+            ...(filters.assignee === undefined ? {} : { assignee: filters.assignee }),
+            ...(filters.labels === undefined ? {} : { labels: filters.labels }),
             ...(headers === undefined ? {} : { headers }),
         }),
     }).then((items) => items.map(normalizeIssue));

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

@@ -66,7 +66,10 @@ export function createGitHubClient(token) {
 }
 function createGitHubReadClient(octokit, cache) {
     return {
-        listIssues: (owner, repo, maxResults, since) => listIssues(octokit, cache, owner, repo, maxResults, since),
+        listIssues: (owner, repo, maxResults, since, filters) => listIssues(octokit, cache, owner, repo, maxResults, {
+            ...(since === undefined ? {} : { since }),
+            ...(filters === undefined ? {} : { filters }),
+        }),
         listPullRequests: (owner, repo, maxResults) => listPullRequests(octokit, cache, owner, repo, maxResults),
         listIssueComments: (owner, repo, issueNumber, pageSize, since, maxResults) => listIssueComments(octokit, cache, owner, repo, issueNumber, {
             pageSize,

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

@@ -1,3 +1,4 @@
+import { gitHubIssueQueryFilters } from '../application/intake-policy.js';
 import { GitHubEventType } from '../contracts/events.js';
 import { createGitHubAdapterHealthRegistry, } from './adapter-health-registry.js';
 import { issueCommentEventsFor, reviewCommentEventsFor, reviewEventsFor, } from './comment-source.js';
@@ -65,7 +66,7 @@ export function createGitHubSource(config, client, adapter, requests = createGit
 function limitGitHubSourceClient(client, requests) {
     return {
         ...client,
-        listIssues: (owner, repo, maxResults, since) => requests.run(() => client.listIssues(owner, repo, maxResults, since)),
+        listIssues: (owner, repo, maxResults, since, filters) => requests.run(() => client.listIssues(owner, repo, maxResults, since, filters)),
         listPullRequests: (owner, repo, maxResults) => requests.run(() => client.listPullRequests(owner, repo, maxResults)),
         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)),
@@ -96,22 +97,14 @@ async function pollRepository(input) {
         repository: `${owner}/${repo}`,
     };
     const since = overlapSince(input.watermark, config.polling.lookbackMs);
-    const [issuesResult, pullRequestsResult] = await Promise.allSettled([
-        client.listIssues(owner, repo, config.polling.maxPerRepo, since),
-        client.listPullRequests(owner, repo, config.polling.maxPerRepo),
-    ]);
-    if (isFulfilled(issuesResult))
-        health.recordSuccess(context.repository, 'poll');
-    else {
-        reportPartialPollFailure(context.repository, 'issues');
-        health.recordFailure(context.repository, 'poll', issuesResult.reason);
-    }
-    if (isFulfilled(pullRequestsResult))
-        health.recordSuccess(context.repository, 'poll');
-    else {
-        reportPartialPollFailure(context.repository, 'pull requests');
-        health.recordFailure(context.repository, 'poll', pullRequestsResult.reason);
-    }
+    const [issuesResult, pullRequestsResult] = await fetchRepositoryItems({
+        client,
+        config,
+        owner,
+        repo,
+        since,
+    });
+    reportRepositoryReadResults(context, health, issuesResult, pullRequestsResult);
     const issues = isFulfilled(issuesResult) ? issuesResult.value : [];
     const pullRequestPayloads = isFulfilled(pullRequestsResult)
         ? pullRequestsResult.value.filter((pullRequest) => since === undefined || pullRequest.updated_at >= since)
@@ -150,6 +143,25 @@ async function pollRepository(input) {
         ],
     };
 }
+function fetchRepositoryItems(input) {
+    const { client, config, owner, repo, since } = input;
+    return Promise.allSettled([
+        client.listIssues(owner, repo, config.polling.maxPerRepo, since, gitHubIssueQueryFilters(config.intake)),
+        client.listPullRequests(owner, repo, config.polling.maxPerRepo),
+    ]);
+}
+function reportRepositoryReadResults(context, health, issuesResult, pullRequestsResult) {
+    reportRepositoryReadResult(context.repository, health, 'issues', issuesResult);
+    reportRepositoryReadResult(context.repository, health, 'pull requests', pullRequestsResult);
+}
+function reportRepositoryReadResult(repository, health, read, result) {
+    if (isFulfilled(result)) {
+        health.recordSuccess(repository, 'poll');
+        return;
+    }
+    reportPartialPollFailure(repository, read);
+    health.recordFailure(repository, 'poll', result.reason);
+}
 function isFulfilled(result) {
     return 'value' in result;
 }

package/dist/src/persistence/filesystem/file-event-journal.js

@@ -15,6 +15,15 @@ export class FileEventJournal {
         return this.changeSignalSource;
     }
     cached;
+    // Every read (readStream/readAll/readLatest/latestGlobalPosition) reaches
+    // scan(), and the resident host's tick loop calls those many times a
+    // second while work is progressing. Without coalescing, calls that land
+    // concurrently each independently decide the cache is stale and each
+    // re-read and re-parse the entire on-disk journal — under I/O pressure
+    // (e.g. a concurrently running build/test process competing for disk),
+    // enough of these can overlap at once to exhaust the heap. Sharing one
+    // in-flight decode among concurrent callers makes that impossible.
+    inFlightScan;
     async append(stream, expectedSequence, drafts) {
         return withFileLock(join(this.root, 'locks', 'event-journal.lock'), async () => {
             const current = await this.scan();
@@ -97,7 +106,17 @@ export class FileEventJournal {
             : [...priorEntries, updatedEntry];
         this.cached = { entries, events: [...priorEvents, ...newEnvelopes] };
     }
-    async scan() {
+    scan() {
+        if (this.inFlightScan !== undefined)
+            return this.inFlightScan;
+        const run = this.scanUncoalesced().finally(() => {
+            if (this.inFlightScan === run)
+                this.inFlightScan = undefined;
+        });
+        this.inFlightScan = run;
+        return run;
+    }
+    async scanUncoalesced() {
         const directory = join(this.root, 'events');
         let files;
         try {

package/dist/src/surfaces/api/contracts/transport-values.js

@@ -1,3 +1,4 @@
+import { ActivityOutcomeKind } from '../../../activities/index.js';
 const commandStatusShape = { accepted: true, completed: true };
 const commandStatuses = Object.keys(commandStatusShape);
 export const AcceptedCommandStatusValue = {
@@ -8,6 +9,13 @@ const runResponseShape = { active: true };
 export const RunResponseField = { Active: Object.keys(runResponseShape)[0] };
 const resourceItemFieldShape = { adapter: true };
 export const ResourceItemField = { Adapter: Object.keys(resourceItemFieldShape)[0] };
+const runResolutionStatusShape = { failed: true, succeeded: true };
+const runResolutionStatuses = Object.keys(runResolutionStatusShape);
+export const RunResolutionStatusValue = {
+    Failed: runResolutionStatuses[0],
+    Succeeded: runResolutionStatuses[1],
+};
+export const ActivityOutcomeKindValue = ActivityOutcomeKind;
 const boardConditionShape = {
     ready: true,
     active: true,

package/dist/src/surfaces/api/presenters/orchestration.js

@@ -1,4 +1,4 @@
-import { isOperatorRetryEligible, } from '../../../orchestration/index.js';
+import { isOperatorRetryEligible, WorkflowStatus, } from '../../../orchestration/index.js';
 import { toWorkItemKey } from '../contracts/work.js';
 export function presentWorkflowInstance(value) {
     return {
@@ -11,6 +11,9 @@ export function presentWorkflowInstance(value) {
             : { parentWorkflowInstanceId: value.parentWorkflowInstanceId }),
         status: value.status,
         currentStage: value.currentStage,
+        ...(value.status === WorkflowStatus.Blocked && value.blockReason !== undefined
+            ? { blockReason: value.blockReason }
+            : {}),
         ...(isOperatorRetryEligible(value) ? { retryEligible: true } : {}),
         ...(value.waitingFor === undefined
             ? {}

package/dist/src/surfaces/cli/commands/sandbox-entrypoint.js

@@ -1,3 +1,17 @@
+/**
+ * Never resolves, and never lets the process exit either. The supervised
+ * child is spawned detached and unref'd (see spawnDetached), so an
+ * unresolved Promise alone is not enough here — a Promise executor registers
+ * no libuv handle, and once other pending I/O quiets down Node treats the
+ * still-pending top-level await as unsettled and exits anyway. A ref'd
+ * timer is a real handle, so it keeps the process alive for as long as this
+ * Promise is meant to.
+ */
+export function waitForever() {
+    return new Promise(() => {
+        setInterval(() => { }, 1 << 30);
+    });
+}
 /**
  * Restarts `wake start` on every exit — a first-boot crash (e.g. missing
  * sandbox auth) must not stop the retry loop, since the operator's only path