@atolis-hq/wake 0.3.20 → 0.3.22

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

@@ -31,7 +31,7 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
     const maintenance = createUpdateMaintenanceLease(paths.wakeRoot);
     const clock = options.clock ?? new SystemClock();
     const ids = new UlidIdGenerator();
-    const { journal, projections, checkpoints, resourceTransitionOrdering, resourceTransitionTriggers, } = composePersistence(paths, clock, options);
+    const { journal, projections, checkpoints } = composePersistence(paths, clock, options);
     const work = createWorkService(journal);
     const lookup = createResourceLookup({ journal, projections });
     const resources = createResourceService(journal, lookup);
@@ -125,8 +125,6 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
         ids,
         wakeRoot,
         scheduleCheckpoints: options.scheduleCheckpoints ?? new FileScheduleCheckpointStore(paths.dataRoot),
-        resourceTransitionOrdering,
-        resourceTransitionTriggers,
         ...(options.decorateDeliveryAdapter === undefined
             ? {}
             : { decorateDeliveryAdapter: options.decorateDeliveryAdapter }),

package/dist/src/bootstrap/index.js

@@ -33,7 +33,6 @@ export function composeControlPlaneHosts(advanceOnce, sleep) {
 }
 export * from './composition-root.js';
 export * from './resource-transition-evidence.js';
-export * from './resource-transition-ordering.js';
 export * from './analytics-projection.js';
 export * from './board-projection.js';
 export * from './config/load-config.js';

package/dist/src/bootstrap/integration-runtime.js

@@ -110,13 +110,11 @@ export async function composeIntegrationRuntime(input) {
             },
         ],
     });
-    input.resourceTransitionTriggers.register(resourceTransitionEvidence.triggers);
-    input.resourceTransitionTriggers.freeze();
-    const resourceTransitions = createResourceTransitionReactor(input.orchestration, resourceTransitionEvidence, input.journal, input.checkpoints, input.resourceTransitionOrdering);
-    input.orchestration.setAcceptSignalOperationCoordinator((operation) => input.resourceTransitionOrdering(async () => {
+    const resourceTransitions = createResourceTransitionReactor(input.orchestration, resourceTransitionEvidence, input.journal, input.checkpoints);
+    input.orchestration.setAcceptSignalOperationCoordinator(async (operation) => {
         await resourceTransitions.drain();
         return operation();
-    }));
+    });
     const outcomes = new DeliveryOutcomeReactor(input.journal, input.checkpoints, input.orchestration);
     const catchUpProjections = async () => {
         await projectionRunner.runRegisteredOnce();

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

@@ -1,19 +1,11 @@
 import { FileCheckpointStore, FileEventJournal, FileProjectionStore, } from '../persistence/index.js';
-import { createResourceTransitionOrdering, createTriggerAwareEventJournal, createTriggerRegistry, } from './resource-transition-ordering.js';
 function identity(value) {
     return value;
 }
 export function composePersistence(paths, clock, options) {
-    const resourceTransitionOrdering = createResourceTransitionOrdering(options.journal === undefined
-        ? `${paths.locksRoot}/resource-transition-ordering.lock`
-        : undefined);
-    const resourceTransitionTriggers = createTriggerRegistry();
-    const journal = createTriggerAwareEventJournal((options.decorateJournal ?? identity)(options.journal ?? new FileEventJournal(paths.dataRoot, clock)), resourceTransitionTriggers, resourceTransitionOrdering);
     return {
-        journal,
+        journal: (options.decorateJournal ?? identity)(options.journal ?? new FileEventJournal(paths.dataRoot, clock)),
         projections: (options.decorateProjections ?? identity)(options.projections ?? new FileProjectionStore(paths.dataRoot)),
         checkpoints: (options.decorateCheckpoints ?? identity)(options.checkpoints ?? new FileCheckpointStore(paths.dataRoot)),
-        resourceTransitionOrdering,
-        resourceTransitionTriggers,
     };
 }

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 = "gea46475";
+export const wakeVersion = "gd39350a";

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

@@ -1,4 +1,5 @@
 import { ActivityOutcomeKind, ReviewActorKind, ReviewDecisionKind, ReviewerAuthorizationSource, createPullRequestService, } from '../../../activities/index.js';
+import { ApprovalAuthorityKind } from '../../../orchestration/index.js';
 import { BuiltInResourceKind, ResourceCorrelationRole, ResourceStreamKind, resourceId, } from '../../../resources/index.js';
 import { UnknownGitHubIdentity } from '../contracts/vocabulary.js';
 import { commandContext } from './inbound-context.js';
@@ -143,6 +144,9 @@ async function applyWorkflowSignal(input) {
                     evidenceId: event.eventId,
                 },
                 providerEventId: event.eventId,
+                ...(event.payload.actor.kind === ReviewActorKind.Human
+                    ? { authority: { kind: ApprovalAuthorityKind.Human } }
+                    : {}),
             }, commandContext(event));
         }
         else if (resumeBlockedOnChanges) {

package/dist/src/orchestration/application/resource-transition-matching.js

@@ -66,7 +66,18 @@ export async function acceptResourceTransition(repository, workflows, id, target
         causationId: `${context.commandId}:${evidenceId}`,
         consent: true,
     });
-    if (decision.kind === 'append')
-        await repository.append(id, loaded.sequence, decision.events);
+    if (decision.kind === 'append') {
+        try {
+            await repository.append(id, loaded.sequence, decision.events);
+        }
+        catch (error) {
+            const reloaded = await repository.load(id);
+            if (reloaded.view !== null &&
+                (reloaded.view.acceptedSignalIds.includes(evidenceId) ||
+                    reloaded.view.waitingFor === undefined))
+                return reloaded.view;
+            throw error;
+        }
+    }
     return (await repository.load(id)).view;
 }

package/dist/src/orchestration/application/resource-transition-reactor.js

@@ -3,7 +3,7 @@ import { selectOrchestrationEvent } from '../contracts/event-decoder.js';
 import { OrchestrationEventType } from '../contracts/events.js';
 const checkpoint = 'reactor:orchestration.resource-transition';
 const batchSize = 100;
-export function createResourceTransitionReactor(orchestration, evidence, journal, checkpoints, coordinate) {
+export function createResourceTransitionReactor(orchestration, evidence, journal, checkpoints) {
     let queue = Promise.resolve();
     const react = async (event, context) => {
         const orchestrationEvent = selectOrchestrationEvent(event);
@@ -40,10 +40,10 @@ export function createResourceTransitionReactor(orchestration, evidence, journal
     return {
         react,
         runOnce(limit = batchSize) {
-            return (coordinate ?? serialize)(() => runBatch(limit));
+            return serialize(() => runBatch(limit));
         },
         drain() {
-            return (coordinate ?? serialize)(async () => {
+            return serialize(async () => {
                 let total = 0;
                 let processed;
                 do {

package/dist/src/orchestration/domain/signal-policy.js

@@ -52,7 +52,10 @@ function signalRejectionReason(state, input) {
     if (state.acceptedSignalIds.includes(signal.providerEventId))
         return 'provider signal was already accepted';
     const expected = state.waitingFor;
-    if (state.status !== WorkflowStatus.Waiting || expected === undefined)
+    if (expected === undefined)
+        return 'WorkflowInstance is not waiting for a signal';
+    if (state.status !== WorkflowStatus.Waiting &&
+        !isBlockedHumanAuthorizedWait(state, signal, expected))
         return 'WorkflowInstance is not waiting for a signal';
     if (!matchesExpectation(signal, expected))
         return 'signal does not match the current expectation';
@@ -66,6 +69,11 @@ function signalRejectionReason(state, input) {
         return 'watch-gate signal outcome is neither done nor rejected';
     return null;
 }
+function isBlockedHumanAuthorizedWait(state, signal, expected) {
+    return (state.status === WorkflowStatus.Blocked &&
+        signal.authority?.kind === ApprovalAuthorityKind.Human &&
+        expected.from?.some((authority) => authority.kind === ApprovalAuthorityKind.Human) === true);
+}
 function signalAuthorityAccepted(signal, expected, consent) {
     if (expected.from === undefined)
         return true;

package/package.json

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

package/prompts/refine.md

@@ -26,6 +26,14 @@ Your job here is only to:
   response (do not try to save it to a file).
 - If underspecified, ask the smallest set of clarifying questions needed.
 
+"Underspecified" means the requirement or acceptance criteria are unclear or
+contradictory — not that an implementation detail is undecided. Investigate
+the codebase and decide design questions (module ownership, event/projection
+shape, which pattern to extend); state the decision as an assumption in your
+plan instead of asking. plan-review checks stated assumptions and rejects a
+wrong one. Block only when the ticket's own intent can't be determined by
+reading the repository.
+
 Wake will provide the issue data and comments below in a delimited untrusted
 data block.
 {{else}}

package/dist/src/bootstrap/resource-transition-ordering.js

@@ -1,67 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { acquireFileLock } from '../persistence/index.js';
-export function createTriggerRegistry() {
-    const triggers = new Set();
-    let frozen = false;
-    return {
-        register(values) {
-            if (frozen)
-                throw new Error('Resource transition trigger registry is frozen');
-            values.forEach((value) => triggers.add(value));
-        },
-        freeze() {
-            frozen = true;
-        },
-        includes(eventType) {
-            return triggers.has(eventType);
-        },
-    };
-}
-export function createResourceTransitionOrdering(lockPath) {
-    const active = new AsyncLocalStorage();
-    let queue = Promise.resolve();
-    const coordinate = (operation) => {
-        if (active.getStore() === true)
-            return operation();
-        const result = queue.then(async () => {
-            const lock = lockPath === undefined ? undefined : await waitForFileLock(lockPath);
-            try {
-                return await active.run(true, operation);
-            }
-            finally {
-                await lock?.release();
-            }
-        });
-        queue = result.catch(() => { });
-        return result;
-    };
-    return coordinate;
-}
-async function waitForFileLock(lockPath) {
-    for (;;) {
-        const lock = await acquireFileLock(lockPath, {
-            staleAfterMs: 60_000,
-            staleRequiresDeadProcess: true,
-        });
-        if (lock.acquired)
-            return lock;
-        await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-}
-export function createTriggerAwareEventJournal(journal, registry, coordinate) {
-    return {
-        append(stream, expectedSequence, events) {
-            const append = () => journal.append(stream, expectedSequence, events);
-            return events.some(({ eventType }) => registry.includes(eventType))
-                ? coordinate(append)
-                : append();
-        },
-        readStream: (stream) => journal.readStream(stream),
-        readAll: (afterGlobalPosition, limit) => journal.readAll(afterGlobalPosition, limit),
-        ...(journal.readLatest === undefined
-            ? {}
-            : {
-                readLatest: (beforeGlobalPosition, limit) => journal.readLatest(beforeGlobalPosition, limit),
-            }),
-    };
-}