@atolis-hq/wake 0.3.80 → 0.3.82

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

@@ -229,6 +229,21 @@ function createSystemApplications(root, now) {
                 meta: sampledMeta(sampledAt),
             };
         },
+        async commands() {
+            const sampledAt = now();
+            return {
+                data: {
+                    adapters: root.providers
+                        .filter((instance) => instance.commands !== undefined)
+                        .map((instance) => ({
+                        adapter: instance.adapter,
+                        provider: instance.provider,
+                        commands: instance.commands(),
+                    })),
+                },
+                meta: sampledMeta(sampledAt),
+            };
+        },
     };
 }
 function commandAccepted(command, acceptedAt) {

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 = "g3986c6c";
+export const wakeVersion = "ga32fb11";

package/dist/src/integrations/github/application/inbound-comment-syntax.js

@@ -1,15 +1,17 @@
 import { ReviewActorKind } from '../../../activities/index.js';
+import { GitHubBuiltInCommand } from '../contracts/vocabulary.js';
 export function isHumanNonWakeReply(actorKind, body) {
     return actorKind === ReviewActorKind.Human && !body.includes('<!-- wake:');
 }
 export function recognizedCommand(body) {
     const normalized = body.trim().toLowerCase();
-    if (normalized === '/approved')
-        return '/approved';
-    if (normalized === '/changes' || normalized.startsWith('/changes '))
-        return '/changes';
-    if (normalized === '/retry')
-        return '/retry';
+    if (normalized === GitHubBuiltInCommand.Approved)
+        return GitHubBuiltInCommand.Approved;
+    if (normalized === GitHubBuiltInCommand.Changes ||
+        normalized.startsWith(`${GitHubBuiltInCommand.Changes} `))
+        return GitHubBuiltInCommand.Changes;
+    if (normalized === GitHubBuiltInCommand.Retry)
+        return GitHubBuiltInCommand.Retry;
     return null;
 }
 export function isPlainReply(body) {
@@ -17,5 +19,5 @@ export function isPlainReply(body) {
     return normalized.length > 0 && !normalized.startsWith('/');
 }
 export function shouldResumeBlockedStage(command, plainReply) {
-    return command === '/changes' || plainReply;
+    return command === GitHubBuiltInCommand.Changes || plainReply;
 }

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

@@ -3,7 +3,7 @@ import { ActivityOutcomeKind, ReviewActorKind, ReviewDecisionKind, ReviewerAutho
 import { ApprovalAuthorityKind, selectOperatorRetryTarget, } from '../../../orchestration/index.js';
 import { BuiltInResourceKind, ResourceCorrelationRole, ResourceStreamKind, resourceId, } from '../../../resources/index.js';
 import { WorkStatus } from '../../../work/index.js';
-import { UnknownGitHubIdentity } from '../contracts/vocabulary.js';
+import { GitHubBuiltInCommand, UnknownGitHubIdentity } from '../contracts/vocabulary.js';
 import { isHumanNonWakeReply, isPlainReply, recognizedCommand, shouldResumeBlockedStage, } from './inbound-comment-syntax.js';
 import { commandContext } from './inbound-context.js';
 import { ignoreIneligibleOperatorRetry } from './operator-retry-command.js';
@@ -77,7 +77,7 @@ async function applyIssueReviewSignal(input) {
     const resource = await resources.get(resourceIdValue);
     const command = recognizedCommand(event.payload.body);
     const plainReply = isPlainReply(event.payload.body);
-    if (command === '/retry') {
+    if (command === GitHubBuiltInCommand.Retry) {
         return applyIssueRetrySignal({
             event,
             resources,
@@ -93,7 +93,9 @@ async function applyIssueReviewSignal(input) {
             work,
             orchestration,
             resourceId: resourceIdValue,
-            outcome: command === '/approved' ? ActivityOutcomeKind.Done : ActivityOutcomeKind.Rejected,
+            outcome: command === GitHubBuiltInCommand.Approved
+                ? ActivityOutcomeKind.Done
+                : ActivityOutcomeKind.Rejected,
             acceptWaitingSignal: command !== null,
             resumeBlockedOnChanges: shouldResumeBlockedStage(command, plainReply),
         });
@@ -153,8 +155,10 @@ async function applyIssueApprovalSignal(input) {
         work,
         orchestration,
         resourceId: resourceIdValue,
-        outcome: command === '/approved' ? ActivityOutcomeKind.Done : ActivityOutcomeKind.Rejected,
-        resumeBlockedOnChanges: command === '/changes',
+        outcome: command === GitHubBuiltInCommand.Approved
+            ? ActivityOutcomeKind.Done
+            : ActivityOutcomeKind.Rejected,
+        resumeBlockedOnChanges: command === GitHubBuiltInCommand.Changes,
     });
 }
 async function applyPullRequestWorkflowSignal(input) {

package/dist/src/integrations/github/application/review-command-translator.js

@@ -1,7 +1,8 @@
 import { ReviewDecisionKind, } from '../../../activities/index.js';
+import { GitHubBuiltInCommand } from '../contracts/vocabulary.js';
 export function translateGitHubReviewCommand(input) {
     const command = input.body.trim();
-    if (command !== '/accepted' && command !== '/changes')
+    if (command !== GitHubBuiltInCommand.Accepted && command !== GitHubBuiltInCommand.Changes)
         return null;
     return {
         resourceId: input.resourceId,
@@ -11,6 +12,8 @@ export function translateGitHubReviewCommand(input) {
         resourceAuthorId: input.resourceAuthorId,
         authorization: input.authorization,
         providerEventId: input.providerEventId,
-        kind: command === '/accepted' ? ReviewDecisionKind.Accepted : ReviewDecisionKind.ChangesRequested,
+        kind: command === GitHubBuiltInCommand.Accepted
+            ? ReviewDecisionKind.Accepted
+            : ReviewDecisionKind.ChangesRequested,
     };
 }

package/dist/src/integrations/github/contracts/config.js

@@ -52,5 +52,10 @@ export const gitHubConfigSchema = z
         .object({ postStatusComments: z.boolean().default(true) })
         .strict()
         .default({ postStatusComments: true }),
+    // Additional command syntax to advertise on the commands/instructions
+    // surface alongside the adapter's built-in commands. Purely descriptive:
+    // Wake does not recognize these itself, so any behavior they imply must
+    // be handled by whatever reads the comment (e.g. a workflow prompt).
+    commands: z.array(z.string().trim().min(1)).default([]),
 })
     .strict();

package/dist/src/integrations/github/contracts/vocabulary.js

@@ -54,3 +54,15 @@ export const GitHubOutboundAction = {
     Reply: 'reply',
     Close: 'close',
 };
+// Comment-channel commands the GitHub adapter recognizes from human replies.
+// /approved and /changes drive issue-review and PR-issue-comment signals;
+// /accepted and /changes drive formal (native) PR review comments; /retry
+// resumes a blocked/failed stage. Kept as the single source of truth for both
+// recognition (inbound-comment-syntax.ts, review-command-translator.ts) and
+// the commands/instructions surface, so the two cannot drift.
+export const GitHubBuiltInCommand = defineClosedVocabulary({
+    Approved: '/approved',
+    Accepted: '/accepted',
+    Changes: '/changes',
+    Retry: '/retry',
+});

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

@@ -1,4 +1,5 @@
 import { ReviewerAuthorizationSource, } from '../../../activities/index.js';
+import { GitHubBuiltInCommand } from '../contracts/vocabulary.js';
 import { issueCommentObservation } from './issue-source.js';
 import { mergeBatches, reportPartialPollFailure } from './poll-watermark.js';
 import { githubReviewObservation } from './review-source.js';
@@ -69,7 +70,7 @@ async function issueCommentEventsForComment(context, issue, comment) {
     return event === null ? [] : [event];
 }
 async function retryAuthorization(context, comment) {
-    if (comment.body?.trim().toLowerCase() !== '/retry')
+    if (comment.body?.trim().toLowerCase() !== GitHubBuiltInCommand.Retry)
         return undefined;
     const login = comment.user?.login;
     if (login === undefined || context.client.collaboratorPermission === undefined)

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

@@ -3,7 +3,7 @@ import { createEventDraft, EventActorKind, EventSourceKind } from '../../../kern
 import { integrationStream } from '../../contracts/streams.js';
 import { GitHubEventType } from '../contracts/events.js';
 import { formatGitHubResourceKey } from '../contracts/external-key.js';
-import { GitHubAdapter, GitHubReviewState, UnknownGitHubIdentity, } from '../contracts/vocabulary.js';
+import { GitHubAdapter, GitHubBuiltInCommand, GitHubReviewState, UnknownGitHubIdentity, } from '../contracts/vocabulary.js';
 export function githubReviewObservation(input) {
     const body = input.review.body?.trim();
     const command = reviewCommand(input.review.state);
@@ -62,8 +62,8 @@ function configuredAuthorization(actorId, reviewers) {
 }
 function reviewCommand(state) {
     if (state === GitHubReviewState.Approved)
-        return '/accepted';
-    return state === GitHubReviewState.ChangesRequested ? '/changes' : null;
+        return GitHubBuiltInCommand.Accepted;
+    return state === GitHubReviewState.ChangesRequested ? GitHubBuiltInCommand.Changes : null;
 }
 function sameIdentity(left, right) {
     return left.toLowerCase() === right.toLowerCase();

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

@@ -6,6 +6,7 @@ import { translateGitHubOutbound } from './application/outbound-translator.js';
 import { createGitHubWakeLabelReconciler } from './application/wake-labels.js';
 import { gitHubConfigSchema } from './contracts/config.js';
 import { GitHubEventType } from './contracts/events.js';
+import { GitHubBuiltInCommand } from './contracts/vocabulary.js';
 import { createGitHubAdapterHealthRegistry } from './infrastructure/adapter-health-registry.js';
 import { createGitHubClient } from './infrastructure/client.js';
 import { createGitHubDelivery } from './infrastructure/delivery.js';
@@ -43,6 +44,10 @@ export const gitHubProviderDefinition = {
                 requests,
             }),
             health: () => health.snapshotAll(),
+            commands: () => [
+                ...Object.values(GitHubBuiltInCommand).map((syntax) => ({ syntax })),
+                ...config.commands.map((syntax) => ({ syntax })),
+            ],
             delivery: createGitHubDelivery(async (intent, idempotencyKey) => {
                 const resource = await services.resources.get(resourceId(intent.resourceId));
                 if (resource === null)

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

@@ -53,9 +53,10 @@ export class FileEventJournal {
                 const directory = join(this.root, 'events');
                 await mkdir(directory, { recursive: true });
                 const day = recordedAt.slice(0, 10);
-                await appendFile(join(directory, `${day}.jsonl`), newEnvelopes.map((event) => JSON.stringify(event)).join('\n') + '\n', 'utf8');
+                const file = `${day}.jsonl`;
+                await appendFile(join(directory, file), newEnvelopes.map((event) => JSON.stringify(event)).join('\n') + '\n', 'utf8');
+                await this.extendCache(file, current, newEnvelopes);
             }
-            this.cached = undefined;
             return finalizedEnvelopes;
         });
     }
@@ -77,6 +78,20 @@ export class FileEventJournal {
         const events = await this.scan();
         return events.at(-1)?.globalPosition ?? 0;
     }
+    // Extends the cache in place rather than invalidating it, so a self-caused
+    // write doesn't force the next read (by this call or any other reader
+    // sharing this instance) to re-parse the entire on-disk history. Only a
+    // change this instance didn't make itself — another process writing to the
+    // same journal — falls through to scan()'s full re-read.
+    async extendCache(file, priorEvents, newEnvelopes) {
+        const info = await stat(join(this.root, 'events', file));
+        const updatedEntry = { file, size: info.size, mtimeMs: info.mtimeMs };
+        const priorEntries = this.cached?.entries ?? [];
+        const entries = priorEntries.some((entry) => entry.file === file)
+            ? priorEntries.map((entry) => (entry.file === file ? updatedEntry : entry))
+            : [...priorEntries, updatedEntry];
+        this.cached = { entries, events: [...priorEvents, ...newEnvelopes] };
+    }
     async scan() {
         const directory = join(this.root, 'events');
         let files;
@@ -90,11 +105,11 @@ export class FileEventJournal {
                 return [];
             throw error;
         }
-        const fingerprint = (await Promise.all(files.map(async (file) => {
+        const entries = await Promise.all(files.map(async (file) => {
             const info = await stat(join(directory, file));
-            return `${file}:${info.size}:${info.mtimeMs}`;
-        }))).join('|');
-        if (this.cached?.fingerprint === fingerprint)
+            return { file, size: info.size, mtimeMs: info.mtimeMs };
+        }));
+        if (this.cached !== undefined && sameEntries(this.cached.entries, entries))
             return this.cached.events;
         const events = [];
         for (const file of files) {
@@ -115,10 +130,17 @@ export class FileEventJournal {
                 }
             }
         }
-        this.cached = { fingerprint, events };
+        this.cached = { entries, events };
         return events;
     }
 }
+function sameEntries(a, b) {
+    return (a.length === b.length &&
+        a.every((entry, index) => {
+            const other = b[index];
+            return (entry.file === other.file && entry.size === other.size && entry.mtimeMs === other.mtimeMs);
+        }));
+}
 const key = (stream) => `${stream.kind}:${stream.id}`;
 const sameDraft = (event, draft) => isDeepStrictEqual({
     eventId: event.eventId,

package/dist/src/persistence/filesystem/file-projection-store.js

@@ -17,9 +17,25 @@ export class FileProjectionStore {
             throw error;
         }
     }
+    // Patches the cached entry in place rather than invalidating the whole
+    // namespace, so a self-caused write doesn't force the next list() to
+    // re-read every other unchanged projection file in the namespace. Falls
+    // back to a full list() re-read for a namespace nothing has cached yet.
     async write(projection) {
-        await atomicJson(this.path(projection.namespace, projection.key), projection);
-        this.listCache.delete(projection.namespace);
+        const path = this.path(projection.namespace, projection.key);
+        await atomicJson(path, projection);
+        const cached = this.listCache.get(projection.namespace);
+        if (cached === undefined)
+            return;
+        const info = await stat(path);
+        const file = `${encode(projection.key)}.json`;
+        const updatedEntry = {
+            file,
+            size: info.size,
+            mtimeMs: info.mtimeMs,
+            value: projection,
+        };
+        this.listCache.set(projection.namespace, [...cached.filter((entry) => entry.file !== file), updatedEntry].sort((a, b) => a.file < b.file ? -1 : a.file > b.file ? 1 : 0));
     }
     // Callers (advance-once, orchestration-service, DeliveryService, ...) list()
     // an entire namespace unconditionally on every control-plane tick, even when
@@ -41,16 +57,21 @@ export class FileProjectionStore {
             }
             throw error;
         }
-        const fingerprint = (await Promise.all(files.map(async (file) => {
+        const stats = await Promise.all(files.map(async (file) => {
             const info = await stat(join(directory, file));
-            return `${file}:${info.size}:${info.mtimeMs}`;
-        }))).join('|');
+            return { file, size: info.size, mtimeMs: info.mtimeMs };
+        }));
         const cached = this.listCache.get(namespace);
-        if (cached?.fingerprint === fingerprint)
-            return cached.entries;
-        const entries = await Promise.all(files.map(async (file) => JSON.parse(await readFile(join(directory, file), 'utf8'))));
-        this.listCache.set(namespace, { fingerprint, entries });
-        return entries;
+        if (cached !== undefined && sameProjectionFiles(cached, stats))
+            return cached.map((entry) => entry.value);
+        const entries = await Promise.all(stats.map(async ({ file, size, mtimeMs }) => ({
+            file,
+            size,
+            mtimeMs,
+            value: JSON.parse(await readFile(join(directory, file), 'utf8')),
+        })));
+        this.listCache.set(namespace, entries);
+        return entries.map((entry) => entry.value);
     }
     async clear(namespace) {
         await rm(namespace === undefined
@@ -65,6 +86,13 @@ export class FileProjectionStore {
         return join(this.root, 'projections', encode(namespace), `${encode(key)}.json`);
     }
 }
+function sameProjectionFiles(cached, stats) {
+    return (cached.length === stats.length &&
+        cached.every((entry, index) => {
+            const other = stats[index];
+            return (entry.file === other.file && entry.size === other.size && entry.mtimeMs === other.mtimeMs);
+        }));
+}
 export function encode(value) {
     if (value.length === 0 || /[\\/]/.test(value))
         throw new Error('Storage name must not contain path separators');

package/dist/src/surfaces/api/routes/read.js

@@ -36,6 +36,8 @@ async function readSingleton(applications, url) {
             return noQuery(url, async () => ok(await applications.system.health()));
         case '/api/v1/system/configuration':
             return noQuery(url, async () => ok(await applications.system.configuration()));
+        case '/api/v1/system/commands':
+            return noQuery(url, async () => ok(await applications.system.commands()));
         default:
             return undefined;
     }

package/dist/src/surfaces/api/routes/system.js

@@ -1 +1,5 @@
-export const systemRoutes = ['/api/v1/system/health', '/api/v1/system/configuration'];
+export const systemRoutes = [
+    '/api/v1/system/health',
+    '/api/v1/system/configuration',
+    '/api/v1/system/commands',
+];