npm - @atolis-hq/wake - Versions diffs - 0.2.96 → 0.3.0 - Mend

@atolis-hq/wake 0.2.96 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (442) hide show

package/dist/src/surfaces/web-assets/index.html ADDED Viewed

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Wake</title>
+    <script type="module" crossorigin src="/assets/index-ipB6JPGU.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Bfn4FwZG.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/dist/src/surfaces/web-host/asset-source.js ADDED Viewed

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

package/dist/src/surfaces/web-host/packaged-assets.js ADDED Viewed

@@ -0,0 +1,44 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const contentTypeFor = (path) => path.endsWith('.js')
+    ? 'text/javascript; charset=utf-8'
+    : path.endsWith('.css')
+        ? 'text/css; charset=utf-8'
+        : 'application/octet-stream';
+export class PackagedAssets {
+    read;
+    constructor(read) {
+        this.read = read;
+    }
+    async get(path) {
+        const normalized = path.replace(/^\/+/, '');
+        if (normalized.length === 0)
+            return undefined;
+        const body = await this.read(normalized);
+        if (body === undefined)
+            return undefined;
+        const immutable = /[.-][a-z0-9]{4,}\.(?:js|css)$/i.test(normalized);
+        return {
+            body,
+            contentType: contentTypeFor(normalized),
+            headers: { 'cache-control': immutable ? 'public, max-age=31536000, immutable' : 'no-cache' },
+        };
+    }
+}
+export function packagedWebAssetsRoot(moduleUrl = import.meta.url) {
+    return fileURLToPath(new URL('../web-assets/', moduleUrl)).replace(/[\\/]$/, '');
+}
+export function createPackagedAssetSource(moduleUrl = import.meta.url) {
+    const root = packagedWebAssetsRoot(moduleUrl);
+    return new PackagedAssets(async (path) => {
+        if (path.split(/[\\/]/).includes('..'))
+            return undefined;
+        try {
+            return await readFile(join(root, path));
+        }
+        catch (error) {
+            return error.code === 'ENOENT' ? undefined : Promise.reject(error);
+        }
+    });
+}

package/dist/src/work/application/work-projection.js ADDED Viewed

@@ -0,0 +1,59 @@
+import { selectWorkEvent, WorkEventType } from '../contracts/events.js';
+import { WorkStatus } from '../contracts/vocabulary.js';
+export const workProjection = {
+    name: 'work',
+    select(event) {
+        const owned = selectWorkEvent(event);
+        return owned === null ? null : { key: owned.stream.id };
+    },
+    initial: () => null,
+    project(previous, event) {
+        const owned = selectWorkEvent(event);
+        if (owned === null)
+            return previous;
+        if (owned.eventType === WorkEventType.ItemCreated)
+            return {
+                workItemId: owned.stream.id,
+                objective: owned.payload.objective,
+                state: WorkStatus.Open,
+                tags: owned.payload.tags ?? [],
+                autoApprovalGranted: false,
+                relatedWorkItems: [],
+            };
+        // Every other event revises an existing item; a fold that has not seen the creation
+        // yet has nothing to revise.
+        return previous === null ? previous : revise(previous, owned);
+    },
+};
+function revise(previous, owned) {
+    switch (owned.eventType) {
+        case WorkEventType.ObjectiveRevised:
+            return { ...previous, objective: owned.payload.objective };
+        case WorkEventType.ItemClosed:
+            return { ...previous, state: WorkStatus.Closed };
+        case WorkEventType.ItemCancelled:
+            return { ...previous, state: WorkStatus.Cancelled };
+        case WorkEventType.AutoApprovalGranted:
+            return { ...previous, autoApprovalGranted: true };
+        case WorkEventType.AutoApprovalRevoked:
+            return { ...previous, autoApprovalGranted: false };
+        case WorkEventType.ItemFrozen:
+            return { ...previous, frozen: true };
+        case WorkEventType.ItemUnfrozen:
+            return { ...previous, frozen: false };
+        case WorkEventType.ItemDeleted:
+            return { ...previous, deleted: true, frozen: false };
+        case WorkEventType.ItemLinked:
+            return link(previous, owned.payload.to, owned.payload.relation);
+        default:
+            return assertNever(owned);
+    }
+}
+function link(previous, workItemId, relation) {
+    return previous.relatedWorkItems.some((item) => item.workItemId === workItemId && item.relation === relation)
+        ? previous
+        : { ...previous, relatedWorkItems: [...previous.relatedWorkItems, { workItemId, relation }] };
+}
+function assertNever(value) {
+    throw new Error(`Unhandled Work event: ${JSON.stringify(value)}`);
+}

package/dist/src/work/application/work-repository.js ADDED Viewed

@@ -0,0 +1,18 @@
+import { decodeWorkEvent, selectWorkEvent, } from '../contracts/events.js';
+import { workItemStream } from '../contracts/streams.js';
+import { foldWorkItem } from '../domain/work-item.js';
+export class WorkRepository {
+    journal;
+    constructor(journal) {
+        this.journal = journal;
+    }
+    async load(workItemId) {
+        const events = await this.journal.readStream(workItemStream(workItemId));
+        const owned = events.map(selectWorkEvent).filter((event) => event !== null);
+        return { sequence: events.length, view: foldWorkItem(owned) };
+    }
+    async append(workItemId, expectedSequence, drafts) {
+        const events = await this.journal.append(workItemStream(workItemId), expectedSequence, drafts);
+        return events.map(decodeWorkEvent);
+    }
+}

package/dist/src/work/application/work-service.js ADDED Viewed

@@ -0,0 +1,117 @@
+import { createEventDraft, EventSourceKind, } from '../../kernel/index.js';
+import { WorkEventType } from '../contracts/events.js';
+import { workItemStream } from '../contracts/streams.js';
+import { WorkStatus } from '../contracts/vocabulary.js';
+import { WorkRepository } from './work-repository.js';
+export function createWorkService(journal) {
+    const repository = new WorkRepository(journal);
+    const change = (workItemId, context, draft, allowMissing, requireOpen) => changeWorkItem(repository, workItemId, context, draft, allowMissing, requireOpen);
+    return {
+        async create(command, context) {
+            const loaded = await repository.load(command.workItemId);
+            const draft = workDraft(command.workItemId, context, WorkEventType.ItemCreated, {
+                objective: command.objective,
+                ...(command.tags === undefined ? {} : { tags: command.tags }),
+            });
+            if (loaded.view !== null)
+                return change(command.workItemId, context, draft, true);
+            return change(command.workItemId, context, draft, true);
+        },
+        revise(command, context) {
+            return change(command.workItemId, context, workDraft(command.workItemId, context, WorkEventType.ObjectiveRevised, {
+                objective: command.objective,
+            }));
+        },
+        link(command, context) {
+            return change(command.from, context, workDraft(command.from, context, WorkEventType.ItemLinked, {
+                to: command.to,
+                relation: command.relation,
+            }));
+        },
+        close(workItemId, reason, context) {
+            return change(workItemId, context, workDraft(workItemId, context, WorkEventType.ItemClosed, { reason }));
+        },
+        cancel(workItemId, reason, context) {
+            return change(workItemId, context, workDraft(workItemId, context, WorkEventType.ItemCancelled, { reason }));
+        },
+        grantAutoApproval(workItemId, context) {
+            return setAutoApproval(repository, change, workItemId, context, true);
+        },
+        revokeAutoApproval(workItemId, context) {
+            return setAutoApproval(repository, change, workItemId, context, false);
+        },
+        freeze(workItemId, context) {
+            return setFrozen(repository, change, workItemId, context, true);
+        },
+        unfreeze(workItemId, context) {
+            return setFrozen(repository, change, workItemId, context, false);
+        },
+        delete(workItemId, context) {
+            return setDeleted(repository, change, workItemId, context);
+        },
+        async get(workItemId) {
+            return (await repository.load(workItemId)).view;
+        },
+    };
+}
+async function changeWorkItem(repository, workItemId, context, draft, allowMissing = false, requireOpen = true) {
+    const loaded = await repository.load(workItemId);
+    if (!allowMissing && loaded.view === null)
+        throw new Error(`WorkItem ${workItemId} does not exist`);
+    if (loaded.view !== null && loaded.view.deleted) {
+        throw new Error(`WorkItem ${workItemId} is deleted`);
+    }
+    if (requireOpen && loaded.view !== null && loaded.view.state !== WorkStatus.Open) {
+        throw new Error(`WorkItem ${workItemId} is ${loaded.view.state}`);
+    }
+    await repository.append(workItemId, loaded.sequence, [draft]);
+    const result = await repository.load(workItemId);
+    if (result.view === null)
+        throw new Error(`WorkItem ${workItemId} was not created`);
+    return result.view;
+}
+// Operator consent is a durable sibling of freeze/unfreeze. Setting it to the value it
+// already holds appends nothing, so replay cannot manufacture consent history.
+async function setAutoApproval(repository, change, workItemId, context, granted) {
+    const current = (await repository.load(workItemId)).view;
+    if (current === null)
+        throw new Error(`WorkItem ${workItemId} does not exist`);
+    if (current.autoApprovalGranted === granted)
+        return current;
+    const eventType = granted ? WorkEventType.AutoApprovalGranted : WorkEventType.AutoApprovalRevoked;
+    return change(workItemId, context, workDraft(workItemId, context, eventType, {}));
+}
+function workDraft(workItemId, context, eventType, payload) {
+    return createEventDraft({
+        eventId: `${context.commandId}:${eventType}`,
+        eventType,
+        occurredAt: context.occurredAt,
+        correlationId: context.correlationId,
+        causationId: context.commandId,
+        actor: context.actor,
+        source: { kind: EventSourceKind.Internal, id: 'work-service' },
+        stream: workItemStream(workItemId),
+        payload,
+    });
+}
+async function setFrozen(repository, change, workItemId, context, frozen) {
+    const current = (await repository.load(workItemId)).view;
+    if (current === null)
+        throw new Error(`WorkItem ${workItemId} does not exist`);
+    if (current.deleted)
+        throw new Error(`WorkItem ${workItemId} is deleted`);
+    if (current.frozen === frozen)
+        return current;
+    return change(workItemId, context, workDraft(workItemId, context, frozen ? WorkEventType.ItemFrozen : WorkEventType.ItemUnfrozen, {}));
+}
+async function setDeleted(repository, change, workItemId, context) {
+    const current = (await repository.load(workItemId)).view;
+    if (current === null)
+        throw new Error(`WorkItem ${workItemId} does not exist`);
+    if (current.deleted)
+        return current;
+    // Deletion is a purge escape hatch, not a lifecycle transition — unlike
+    // freeze/revise/etc it must still work once a WorkItem is closed or
+    // cancelled, since that's the common case operators need it for.
+    return change(workItemId, context, workDraft(workItemId, context, WorkEventType.ItemDeleted, {}), false, false);
+}

package/dist/src/work/contracts/commands.js ADDED Viewed

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

package/dist/src/work/contracts/config.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import { z } from 'zod';
2	+ export const workConfigSchema = z.object({}).strict();

package/dist/src/work/contracts/events.js ADDED Viewed

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import { brandedStringSchema, eventEnvelopeSchema, } from '../../kernel/index.js';
+import { workItemId } from './identifiers.js';
+import { WorkStreamKind } from './streams.js';
+export const WorkEventType = {
+    ItemCreated: 'work.item-created',
+    ObjectiveRevised: 'work.objective-revised',
+    ItemLinked: 'work.item-linked',
+    ItemClosed: 'work.item-closed',
+    ItemCancelled: 'work.item-cancelled',
+    AutoApprovalGranted: 'work.auto-approval-granted',
+    AutoApprovalRevoked: 'work.auto-approval-revoked',
+    ItemFrozen: 'work.item-frozen',
+    ItemUnfrozen: 'work.item-unfrozen',
+    ItemDeleted: 'work.item-deleted',
+};
+const streamSchema = z
+    .object({
+    kind: z.literal(WorkStreamKind.WorkItem),
+    id: brandedStringSchema(workItemId),
+})
+    .strict();
+const objectiveSchema = z
+    .object({
+    objective: z.string().refine((objective) => objective.trim().length > 0, {
+        message: 'objective must not be empty',
+    }),
+})
+    .strict();
+const reasonSchema = z.object({ reason: z.string() }).strict();
+const consentSchema = z.object({}).strict();
+const itemCreatedSchema = objectiveSchema.extend({
+    tags: z.array(z.string().trim().min(1)).readonly().optional(),
+});
+const eventSchema = z.discriminatedUnion('eventType', [
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(WorkEventType.ItemCreated),
+        stream: streamSchema,
+        payload: itemCreatedSchema,
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(WorkEventType.ObjectiveRevised),
+        stream: streamSchema,
+        payload: objectiveSchema,
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(WorkEventType.ItemLinked),
+        stream: streamSchema,
+        payload: z
+            .object({
+            to: brandedStringSchema(workItemId),
+            relation: z.enum(['relates-to', 'parent-of', 'child-of']),
+        })
+            .strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(WorkEventType.ItemClosed),
+        stream: streamSchema,
+        payload: reasonSchema,
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(WorkEventType.ItemCancelled),
+        stream: streamSchema,
+        payload: reasonSchema,
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(WorkEventType.AutoApprovalGranted),
+        stream: streamSchema,
+        payload: consentSchema,
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(WorkEventType.AutoApprovalRevoked),
+        stream: streamSchema,
+        payload: consentSchema,
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(WorkEventType.ItemFrozen),
+        stream: streamSchema,
+        payload: consentSchema,
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(WorkEventType.ItemUnfrozen),
+        stream: streamSchema,
+        payload: consentSchema,
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(WorkEventType.ItemDeleted),
+        stream: streamSchema,
+        payload: consentSchema,
+    }),
+]);
+export function decodeWorkEvent(event) {
+    const result = eventSchema.safeParse(event);
+    if (!result.success)
+        throw invalidWorkEvent(event, result.error);
+    return result.data;
+}
+export function selectWorkEvent(event) {
+    return event.eventType.startsWith('work.') ? decodeWorkEvent(event) : null;
+}
+function invalidWorkEvent(event, cause) {
+    return new Error(`Invalid Work event ${event.eventId} at global position ${event.globalPosition} (${event.eventType}): ${cause.message}`, { cause });
+}

package/dist/src/work/contracts/identifiers.js ADDED Viewed

@@ -0,0 +1,5 @@
+export const workItemId = (value) => {
+    if (!/^work-[0-9a-hjkmnp-tv-z]{26}$/.test(value))
+        throw new Error(`Invalid WorkItemId: ${value}. WorkItem identity is minted, never derived.`);
+    return value;
+};

package/dist/src/work/contracts/streams.js ADDED Viewed

@@ -0,0 +1,6 @@
+export const WorkStreamKind = { WorkItem: 'work-item' };
+export const workItemStream = (id) => ({
+    kind: WorkStreamKind.WorkItem,
+    id,
+});
+export const isWorkItemStream = (stream) => stream.kind === WorkStreamKind.WorkItem;

package/dist/src/work/contracts/views.js ADDED Viewed

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

package/dist/src/work/contracts/vocabulary.js ADDED Viewed

@@ -0,0 +1,6 @@
+import { defineClosedVocabulary } from '../../kernel/index.js';
+export const WorkStatus = defineClosedVocabulary({
+    Open: 'open',
+    Closed: 'closed',
+    Cancelled: 'cancelled',
+});

package/dist/src/work/domain/work-item.js ADDED Viewed

@@ -0,0 +1,89 @@
+import { WorkEventType } from '../contracts/events.js';
+import { WorkStatus } from '../contracts/vocabulary.js';
+export function foldWorkItem(events) {
+    if (events.length === 0)
+        return null;
+    if (events[0]?.eventType !== WorkEventType.ItemCreated) {
+        throw new Error(`WorkItem stream must begin with ${WorkEventType.ItemCreated}`);
+    }
+    const id = events[0].stream.id;
+    const state = {
+        objective: events[0].payload.objective,
+        tags: events[0].payload.tags ?? [],
+        lifecycle: WorkStatus.Open,
+        autoApprovalGranted: false,
+        frozen: false,
+        deleted: false,
+        links: [],
+        linkKeys: new Set(),
+    };
+    for (const [index, event] of events.entries())
+        applyEvent(state, event, index, id);
+    return {
+        workItemId: id,
+        objective: state.objective,
+        state: state.lifecycle,
+        tags: state.tags,
+        autoApprovalGranted: state.autoApprovalGranted,
+        frozen: state.frozen,
+        deleted: state.deleted,
+        relatedWorkItems: state.links,
+    };
+}
+function applyEvent(state, event, index, id) {
+    if (event.stream.id !== id) {
+        throw new Error('WorkItem events must belong to the same work-item stream');
+    }
+    switch (event.eventType) {
+        case WorkEventType.ItemCreated:
+            if (index > 0)
+                throw new Error('WorkItem stream cannot contain a second creation event');
+            break;
+        case WorkEventType.ObjectiveRevised:
+            state.objective = event.payload.objective;
+            break;
+        case WorkEventType.ItemLinked:
+            addLink(state, { workItemId: event.payload.to, relation: event.payload.relation });
+            break;
+        default:
+            applyStatusEvent(state, event);
+    }
+}
+function applyStatusEvent(state, event) {
+    switch (event.eventType) {
+        case WorkEventType.ItemClosed:
+            state.lifecycle = WorkStatus.Closed;
+            break;
+        case WorkEventType.ItemCancelled:
+            state.lifecycle = WorkStatus.Cancelled;
+            break;
+        case WorkEventType.AutoApprovalGranted:
+            state.autoApprovalGranted = true;
+            break;
+        case WorkEventType.AutoApprovalRevoked:
+            state.autoApprovalGranted = false;
+            break;
+        case WorkEventType.ItemFrozen:
+            state.frozen = true;
+            break;
+        case WorkEventType.ItemUnfrozen:
+            state.frozen = false;
+            break;
+        case WorkEventType.ItemDeleted:
+            state.deleted = true;
+            state.frozen = false;
+            break;
+        default:
+            assertNever(event);
+    }
+}
+function addLink(state, link) {
+    const key = `${link.workItemId}:${link.relation}`;
+    if (!state.linkKeys.has(key)) {
+        state.linkKeys.add(key);
+        state.links.push(link);
+    }
+}
+function assertNever(value) {
+    throw new Error(`Unhandled Work event: ${JSON.stringify(value)}`);
+}

package/dist/src/work/index.js ADDED Viewed

@@ -0,0 +1,11 @@
+export * from './application/work-projection.js';
+export * from './application/work-repository.js';
+export * from './application/work-service.js';
+export * from './contracts/commands.js';
+export * from './contracts/config.js';
+export * from './contracts/events.js';
+export * from './contracts/identifiers.js';
+export * from './contracts/streams.js';
+export * from './contracts/views.js';
+export * from './contracts/vocabulary.js';
+export * from './domain/work-item.js';

package/docker/Dockerfile CHANGED Viewed

@@ -1,5 +1,5 @@
 # syntax=docker/dockerfile:1
-FROM node:20-bookworm-slim
+FROM node:24-bookworm-slim
 RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
     --mount=type=cache,target=/var/lib/apt/lists,sharing=locked \
@@ -42,14 +42,18 @@ RUN echo "cursor cache bust: ${CURSOR_CACHE_BUST}" \
 WORKDIR /app
 COPY package*.json ./
+COPY src/surfaces/web/package.json src/surfaces/web/package.json
 RUN --mount=type=cache,target=/root/.npm \
-  if [ -f package-lock.json ]; then npm ci; else npm install; fi
+  if [ -f package-lock.json ]; then npm ci --include=dev; else npm install; fi
-COPY . .
+COPY tsconfig.json tsconfig.docker.json ./
+COPY scripts/embed-version.mjs scripts/embed-version.mjs
+COPY assets/ assets/
+COPY src/ src/
 ARG WAKE_BUILD_TAG
-RUN WAKE_BUILD_TAG="$WAKE_BUILD_TAG" npm run build
+RUN WAKE_BUILD_TAG="$WAKE_BUILD_TAG" npm run build:docker
-USER wake
+USER root
 WORKDIR /home/wake
 EXPOSE 4317
@@ -60,4 +64,4 @@ EXPOSE 4317
 # that's fine since it's the very first thing that runs.
 ENV WAKE_MAIN_JS=/app/dist/src/main.js
-ENTRYPOINT ["node", "/app/dist/src/main.js", "sandbox-entrypoint"]
+ENTRYPOINT ["sh", "-c", "set -eu; mkdir -p /wake/.wake; chown -R wake:wake /wake/.wake; exec su wake -s /bin/sh -c 'if [ \"$WAKE_START_ENABLED\" = \"true\" ]; then exec node /app/dist/src/main.js start --wake-root /wake --no-sandbox; else exec sleep infinity; fi'"]

package/docker/Dockerfile.packaged CHANGED Viewed

@@ -1,5 +1,5 @@
 # syntax=docker/dockerfile:1
-FROM node:20-bookworm-slim
+FROM node:24-bookworm-slim
 RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
     --mount=type=cache,target=/var/lib/apt/lists,sharing=locked \
@@ -40,7 +40,7 @@ RUN curl https://cursor.com/install -fsS | HOME=/home/wake bash \
   && chmod +x /home/wake/.local/bin/cursor \
   && chown -R wake:wake /home/wake/.local
-USER wake
+USER root
 WORKDIR /home/wake
 EXPOSE 4317
@@ -50,4 +50,4 @@ EXPOSE 4317
 # sandbox-entrypoint-command.ts) that the CLI should be invoked via the bare
 # `wake` binary that `npm install -g` puts on PATH, rather than a hardcoded
 # npm global lib path that varies by npm/OS setup.
-ENTRYPOINT ["wake", "sandbox-entrypoint"]
+ENTRYPOINT ["sh", "-c", "set -eu; mkdir -p /wake/.wake; chown -R wake:wake /wake/.wake; exec su wake -s /bin/sh -c 'exec wake sandbox-entrypoint'"]

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.2.96",
+  "version": "0.3.0",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {
@@ -8,6 +8,9 @@
     "url": "git+https://github.com/atolis-hq/wake.git"
   },
   "type": "module",
+  "workspaces": [
+    "src/surfaces/web"
+  ],
   "bin": {
     "wake": "dist/src/main.js"
   },
@@ -15,6 +18,7 @@
   "exports": "./dist/src/main.js",
   "files": [
     "dist/src",
+    "dist/src/surfaces/web-assets",
     "docker",
     "prompts",
     "templates",
@@ -29,9 +33,24 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json && node scripts/embed-version.mjs",
-    "prepack": "npm run build",
+    "prepack": "npm run build && npm run build:web",
     "test": "vitest run",
-    "test:watch": "vitest",
+    "test:fast": "npm run test:unit",
+    "check:catalogue": "node scripts/check-functional-catalogue.mjs",
+    "check:scenarios": "node scripts/check-scenario-coverage.mjs",
+    "check:specs": "node scripts/check-specs.mjs",
+    "lint:architecture": "node scripts/check-module-manifests.mjs && node scripts/check-contract-vocabulary.mjs && depcruise --config dependency-cruiser.config.mjs src",
+    "build:docker": "tsc -p tsconfig.docker.json && node scripts/embed-version.mjs && npm run build:web",
+    "build:web": "npm --workspace @atolis-hq/wake-web run build",
+    "test:web": "npm --workspace @atolis-hq/wake-web run test",
+    "test:web:e2e": "npm --workspace @atolis-hq/wake-web run test:e2e",
+    "test:unit": "vitest run --config vitest.unit.config.ts",
+    "test:architecture": "vitest run --config vitest.architecture.config.ts",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts",
+    "test:e2e:live": "vitest run --config vitest.live-e2e.config.ts",
+    "lint:contracts": "node scripts/check-contract-vocabulary.mjs",
+    "knip": "knip --config knip.json",
     "lint": "eslint .",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
@@ -43,7 +62,7 @@
     "smoke:claude": "tsx src/main.ts smoke claude",
     "smoke:codex": "tsx src/main.ts smoke codex",
     "smoke:cursor": "tsx src/main.ts smoke cursor",
-    "verify": "npm run lint && npm run format:check && npm run build && npm test"
+    "verify": "npm run check:catalogue && npm run check:scenarios && npm run lint:architecture && npm run lint && npm run format:check && npm run build && npm test"
   },
   "dependencies": {
     "@octokit/rest": "^22.0.0",
@@ -54,10 +73,16 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@stylistic/eslint-plugin": "^5.10.0",
     "@types/node": "^24.0.0",
+    "@vitest/eslint-plugin": "^1.6.24",
+    "dependency-cruiser": "^17.4.3",
     "eslint": "^10.8.0",
+    "eslint-config-prettier": "^10.1.8",
     "globals": "^17.7.0",
+    "knip": "^5.88.1",
     "prettier": "^3.9.6",
+    "prettier-plugin-organize-imports": "^4.3.0",
     "tsx": "^4.23.1",
     "typescript": "^6.0.3",
     "typescript-eslint": "^8.65.0",

package/prompts/implement.md CHANGED Viewed

@@ -21,7 +21,7 @@ Completion requirements:
   commit message.
 - Push the branch with `git push -u origin {{branch}}`.
 - Open a pull request against main with `gh pr create --base main --head
-  {{branch}} --title "<summary>" --body "Closes #{{issueNumber}}
+  {{branch}} --title "<summary>" --body "Refs #{{issueNumber}}
   <!-- wake:work-item {{workItemKey}} -->"`. Include the
@@ -47,7 +47,7 @@ New comments since your last turn (excludes Wake/bot comments):
 Wake will provide them below in a delimited untrusted data block.
 Reminder of the completion requirements: commit, push {{branch}}, open a PR
-with `gh pr create` closing #{{issueNumber}}, and never merge it yourself. The
+with `gh pr create` referencing #{{issueNumber}}, and never merge it yourself. The
 PR body must include the `<!-- wake:work-item {{workItemKey}} -->` marker
 verbatim.
 {{/if}}