npm - @atolis-hq/wake - Versions diffs - 0.2.67 → 0.2.69 - Mend

@atolis-hq/wake 0.2.67 → 0.2.69

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 (13) hide show

package/dist/src/adapters/claude/claude-runner.js +1 -9
package/dist/src/adapters/codex/codex-runner.js +1 -9
package/dist/src/adapters/cursor/cursor-runner.js +1 -9
package/dist/src/adapters/http/ui-assets.js +45 -3
package/dist/src/adapters/http/ui-data.js +8 -2
package/dist/src/adapters/http/ui-server.js +140 -1
package/dist/src/core/projection-updater.js +56 -1
package/dist/src/core/tick-runner.js +6 -4
package/dist/src/domain/event-types.js +21 -0
package/dist/src/domain/schema.js +0 -14
package/dist/src/domain/work-item-lifecycle.js +10 -0
package/dist/src/version.js +1 -1
package/package.json +1 -1

package/dist/src/adapters/claude/claude-runner.js CHANGED Viewed

@@ -86,15 +86,7 @@ export function runClaudeCommand(input) {
     return runAgentCliCommand(input);
 }
 function resolveModel(options) {
-    const { models, model } = options.settings;
-    const actionSpecificModel = models[options.action];
-    if (actionSpecificModel !== undefined) {
-        return actionSpecificModel;
-    }
-    if (models.default !== undefined) {
-        return models.default;
-    }
-    return model;
+    return options.settings.model;
 }
 function parseClaudePrintOutput(stdout) {
     return parseClaudePrintResult(JSON.parse(stdout));

package/dist/src/adapters/codex/codex-runner.js CHANGED Viewed

@@ -165,15 +165,7 @@ export function classifyCodexCliFailure(input) {
     return 'infra';
 }
 function resolveModel(input) {
-    const { models, model } = input.settings;
-    const actionSpecificModel = models[input.action];
-    if (actionSpecificModel !== undefined) {
-        return actionSpecificModel;
-    }
-    if (models.default !== undefined) {
-        return models.default;
-    }
-    return model;
+    return input.settings.model;
 }
 function readSandboxLogBreadcrumb() {
     const containerName = process.env.WAKE_SANDBOX_CONTAINER_NAME;

package/dist/src/adapters/cursor/cursor-runner.js CHANGED Viewed

@@ -132,15 +132,7 @@ function resolveCursorMode(input) {
     return input.workspaceMode === 'read-only' ? 'ask' : undefined;
 }
 function resolveModel(input) {
-    const { models, model } = input.settings;
-    const actionSpecificModel = models[input.action];
-    if (actionSpecificModel !== undefined) {
-        return actionSpecificModel;
-    }
-    if (models.default !== undefined) {
-        return models.default;
-    }
-    return model;
+    return input.settings.model;
 }
 function readSandboxLogBreadcrumb() {
     const containerName = process.env.WAKE_SANDBOX_CONTAINER_NAME;

package/dist/src/adapters/http/ui-assets.js CHANGED Viewed

@@ -129,8 +129,11 @@ export const indexHtml = `<!DOCTYPE html>
   a:hover { text-decoration: underline; }
   .resource-list { list-style: none; padding: 0; margin: 0 0 1rem; }
   .resource-list li { display: flex; align-items: baseline; gap: 0.4rem; margin-bottom: 0.35rem; font-size: 0.8rem; }
-  .btn { background: rgba(255, 255, 255, 0.08); border: 1px solid rgba(255, 255, 255, 0.18); color: #fff; border-radius: 6px; padding: 0.22rem 0.55rem; cursor: pointer; font-size: 0.78rem; margin-top: 0.4rem; }
+  .action-bar { display: flex; align-items: center; gap: 0.45rem; flex-wrap: wrap; margin: 0.6rem 0 0.2rem; }
+  .btn { background: rgba(255, 255, 255, 0.08); border: 1px solid rgba(255, 255, 255, 0.18); color: #fff; border-radius: 6px; padding: 0.22rem 0.55rem; cursor: pointer; font-size: 0.78rem; }
   .btn:hover:not(:disabled) { border-color: var(--accent-light); background: rgba(45, 212, 191, 0.16); }
+  .btn.danger { background: #5c1f1a; border-color: #ff8f7f; }
+  .btn.danger:hover:not(:disabled) { background: #733027; border-color: #ffd0c8; }
   .btn:disabled { cursor: default; opacity: 0.62; }
 </style>
 </head>
@@ -444,6 +447,8 @@ function renderItemDetails(detail) {
   if (detail.item.wake.workspacePath) {
     body.appendChild(el('p', { class: 'meta', text: 'workspace: ' + detail.item.wake.workspacePath }));
   }
+  const isFrozen = typeof detail.item.context.frozenAt === 'string';
+  const actionBar = el('div', { class: 'action-bar' });
   const lastRun = detail.runs.at(-1);
   if (lastRun && lastRun.sentinel === 'FAILED') {
     const retryBtn = el('button', { type: 'button', class: 'btn', text: 'Retry' });
@@ -459,7 +464,7 @@ function renderItemDetails(detail) {
         document.getElementById('status-summary').textContent = 'retry failed: ' + err.message;
       }
     });
-    body.appendChild(retryBtn);
+    actionBar.appendChild(retryBtn);
   }
   if (detail.item.issue.labels.includes('wake:scheduled-workflow')) {
     const runNowBtn = el('button', { type: 'button', class: 'btn', text: 'Run now' });
@@ -475,7 +480,44 @@ function renderItemDetails(detail) {
         document.getElementById('status-summary').textContent = 'run request failed: ' + err.message;
       }
     });
-    body.appendChild(runNowBtn);
+    actionBar.appendChild(runNowBtn);
+  }
+  const freezeBtn = el('button', { type: 'button', class: 'btn', text: isFrozen ? 'Unfreeze' : 'Freeze' });
+  freezeBtn.addEventListener('click', async () => {
+    const action = isFrozen ? 'unfreeze' : 'freeze';
+    freezeBtn.disabled = true;
+    freezeBtn.textContent = isFrozen ? 'Unfreezing...' : 'Freezing...';
+    try {
+      await postJson('/work-items/' + encodeURIComponent(detail.item.workItemKey) + '/' + action);
+      freezeBtn.textContent = isFrozen ? 'Unfrozen' : 'Frozen';
+      document.getElementById('status-summary').textContent = isFrozen ? 'work item unfrozen' : 'work item frozen';
+    } catch (err) {
+      freezeBtn.disabled = false;
+      freezeBtn.textContent = isFrozen ? 'Unfreeze' : 'Freeze';
+      document.getElementById('status-summary').textContent = action + ' failed: ' + err.message;
+    }
+  });
+  actionBar.appendChild(freezeBtn);
+  const deleteBtn = el('button', { type: 'button', class: 'btn danger', text: 'Delete' });
+  deleteBtn.addEventListener('click', async () => {
+    if (!confirm('Delete this work item from the board and remove its resource correlations?')) return;
+    deleteBtn.disabled = true;
+    deleteBtn.textContent = 'Deleting...';
+    try {
+      await postJson('/work-items/' + encodeURIComponent(detail.item.workItemKey) + '/delete');
+      deleteBtn.textContent = 'Deleted';
+      document.getElementById('status-summary').textContent = 'work item deleted';
+      switchView(currentView, { showLoading: false });
+    } catch (err) {
+      deleteBtn.disabled = false;
+      deleteBtn.textContent = 'Delete';
+      document.getElementById('status-summary').textContent = 'delete failed: ' + err.message;
+    }
+  });
+  actionBar.appendChild(deleteBtn);
+  if (actionBar.childNodes.length > 0) {
+    body.appendChild(actionBar);
   }
   const resources = detail.item.correlatedResources || [];
   if (resources.length > 0) {

package/dist/src/adapters/http/ui-data.js CHANGED Viewed

@@ -2,6 +2,7 @@ import { readFile, readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { buildResourceUri } from '../../domain/resource-uri.js';
 import { isTerminalStage } from '../../domain/stages.js';
+import { isWorkItemDeleted, isWorkItemFrozen } from '../../domain/work-item-lifecycle.js';
 import { workflowForProjection, workflowNameForProjection } from '../../domain/workflows.js';
 function parseLockMetadata(raw) {
     try {
@@ -47,6 +48,9 @@ async function readLockInfo(lockFile, now) {
  * It never decides anything the tick doesn't independently decide — this is a read model.
  */
 function deriveCondition(item, lastRun, config) {
+    if (isWorkItemFrozen(item)) {
+        return { condition: 'needs-human', reason: 'work item frozen' };
+    }
     const stage = item.wake.stage;
     if (isTerminalStage(stage) || item.issue.state === 'closed') {
         return { condition: 'finished', reason: 'terminal stage' };
@@ -126,7 +130,9 @@ export async function buildBoard(input) {
         }
         runTotalsByItem.set(run.workItemKey, existing);
     }
-    return items.map((item) => {
+    return items
+        .filter((item) => !isWorkItemDeleted(item))
+        .map((item) => {
         const lastRun = item.wake.lastRunId === undefined ? null : (runsById.get(item.wake.lastRunId) ?? null);
         const { condition, reason } = deriveCondition(item, lastRun, input.config);
         const activeChildRuns = activeChildRunsForItem(item, runs, input.now);
@@ -654,7 +660,7 @@ function modelKey(run, config) {
     if (runner === undefined || runner.kind === 'fake') {
         return 'unknown';
     }
-    return runner.models[run.action] ?? runner.models.default ?? runner.model;
+    return runner.model;
 }
 function completedAtForItem(item) {
     const doneEntry = item.wake.stageHistory.find((entry) => entry.stage === 'done');

package/dist/src/adapters/http/ui-server.js CHANGED Viewed

@@ -2,9 +2,13 @@ import { createServer } from 'node:http';
 import { randomUUID } from 'node:crypto';
 import { mkdir, rm, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
+import { createLabelsEvent } from '../../core/event-builders.js';
 import { createProjectionUpdater } from '../../core/projection-updater.js';
-import { RETRY_REQUESTED_EVENT, RUN_REQUESTED_EVENT } from '../../domain/event-types.js';
+import { CORRELATION_RETRACTED_EVENT, RETRY_REQUESTED_EVENT, RUN_REQUESTED_EVENT, WORK_ITEM_DELETED_EVENT, WORK_ITEM_FROZEN_EVENT, WORK_ITEM_UNFROZEN_EVENT, } from '../../domain/event-types.js';
 import { configuredTicketSource } from '../../domain/sources.js';
+import { stageLabelForStage } from '../../domain/stages.js';
+import { isWorkItemDeleted, isWorkItemFrozen } from '../../domain/work-item-lifecycle.js';
+import { workflowLabelForWorkflowName, workflowNameForProjection } from '../../domain/workflows.js';
 import { createEventEnvelope } from '../../lib/event-log.js';
 import { writeJsonFile } from '../../lib/json-file.js';
 import { indexHtml } from './ui-assets.js';
@@ -53,6 +57,43 @@ function parseItemPath(segments) {
         ...(trailingIsEvents ? { suffix: 'events' } : {}),
     };
 }
+async function writeTickRequest(stateStore, now, requestedBy) {
+    await writeJsonFile(stateStore.paths.tickRequestFile, {
+        requestId: randomUUID(),
+        requestedAt: now().toISOString(),
+        requestedBy,
+    });
+}
+function buildUiWorkItemEvent(input) {
+    return createEventEnvelope({
+        eventId: input.eventId,
+        workItemKey: input.item.workItemKey,
+        streamScope: 'work-item',
+        direction: 'internal',
+        sourceSystem: 'wake',
+        sourceEventType: input.sourceEventType,
+        sourceRefs: { repo: input.item.issue.repo, issueNumber: input.item.issue.number },
+        occurredAt: input.occurredAt,
+        ingestedAt: input.occurredAt,
+        trigger: 'immediate',
+        payload: { requestedBy: 'ui' },
+    });
+}
+async function appendLabelSyncEvent(input) {
+    const occurredAt = input.now().toISOString();
+    const workflowName = workflowNameForProjection(input.item, input.config);
+    const labelEvent = createLabelsEvent({
+        projection: input.item,
+        runId: `${input.action}-${input.item.workItemKey}-${input.now().getTime()}`,
+        statusLabel: 'wake:status.pending',
+        stageLabel: stageLabelForStage(input.item.wake.stage),
+        workflowLabel: workflowLabelForWorkflowName(workflowName),
+        occurredAt,
+    });
+    const appended = await input.stateStore.appendEventEnvelope(labelEvent);
+    await input.projectionUpdater.rebuildFromEvents([appended]);
+    return labelEvent.eventId;
+}
 export function createUiServer(options) {
     const now = options.now ?? (() => new Date());
     const projectionUpdater = createProjectionUpdater({
@@ -96,6 +137,104 @@ async function handleRequest(req, res, options, now, projectionUpdater) {
         .filter((part) => part.length > 0)
         .map((s) => decodeURIComponent(s));
     const resource = segments[0];
+    if (req.method === 'POST' &&
+        resource === 'work-items' &&
+        segments.length === 3 &&
+        (segments[2] === 'freeze' || segments[2] === 'unfreeze')) {
+        const workItemKey = segments[1] ?? '';
+        const item = await stateStore.readIssueState(workItemKey);
+        if (item === null) {
+            sendJson(res, 404, { error: 'work item not found' });
+            return;
+        }
+        if (isWorkItemDeleted(item)) {
+            sendJson(res, 409, { error: 'work item is deleted' });
+            return;
+        }
+        const action = segments[2];
+        const alreadyInDesiredState = action === 'freeze' ? isWorkItemFrozen(item) : !isWorkItemFrozen(item);
+        if (alreadyInDesiredState) {
+            sendJson(res, 202, { workItemKey, changed: false });
+            return;
+        }
+        const occurredAt = now().toISOString();
+        const eventId = `${action}-${workItemKey}-${now().getTime()}`;
+        const event = buildUiWorkItemEvent({
+            item,
+            eventId,
+            sourceEventType: action === 'freeze' ? WORK_ITEM_FROZEN_EVENT : WORK_ITEM_UNFROZEN_EVENT,
+            occurredAt,
+        });
+        const appended = await stateStore.appendEventEnvelope(event);
+        await projectionUpdater.rebuildFromEvents([appended]);
+        const updated = (await stateStore.readIssueState(workItemKey)) ?? item;
+        const labelEventId = await appendLabelSyncEvent({
+            item: updated,
+            stateStore,
+            projectionUpdater,
+            config,
+            now,
+            action,
+        });
+        await writeTickRequest(stateStore, now, `ui:${action}`);
+        sendJson(res, 202, { workItemKey, eventId, labelEventId, changed: true });
+        return;
+    }
+    if (req.method === 'POST' &&
+        resource === 'work-items' &&
+        segments.length === 3 &&
+        segments[2] === 'delete') {
+        const workItemKey = segments[1] ?? '';
+        const item = await stateStore.readIssueState(workItemKey);
+        if (item === null) {
+            sendJson(res, 404, { error: 'work item not found' });
+            return;
+        }
+        if (isWorkItemDeleted(item)) {
+            sendJson(res, 202, { workItemKey, changed: false });
+            return;
+        }
+        const occurredAt = now().toISOString();
+        const deleteEventId = `delete-${workItemKey}-${now().getTime()}`;
+        const events = [
+            buildUiWorkItemEvent({
+                item,
+                eventId: deleteEventId,
+                sourceEventType: WORK_ITEM_DELETED_EVENT,
+                occurredAt,
+            }),
+            ...item.correlatedResources.map((resourceRef) => createEventEnvelope({
+                eventId: `${deleteEventId}-retract-${resourceRef.resourceUri.replace(/[^a-z0-9]+/gi, '-')}`,
+                workItemKey,
+                streamScope: 'work-item',
+                direction: 'internal',
+                sourceSystem: 'wake',
+                sourceEventType: CORRELATION_RETRACTED_EVENT,
+                sourceRefs: {
+                    repo: item.issue.repo,
+                    issueNumber: item.issue.number,
+                    resourceUri: resourceRef.resourceUri,
+                },
+                occurredAt,
+                ingestedAt: occurredAt,
+                trigger: 'context-only',
+                payload: { resourceUri: resourceRef.resourceUri, requestedBy: 'ui' },
+            })),
+        ];
+        const appended = [];
+        for (const event of events) {
+            appended.push(await stateStore.appendEventEnvelope(event));
+        }
+        await projectionUpdater.rebuildFromEvents(appended);
+        await writeTickRequest(stateStore, now, 'ui:delete');
+        sendJson(res, 202, {
+            workItemKey,
+            deleteEventId,
+            retractedResources: item.correlatedResources.map((resourceRef) => resourceRef.resourceUri),
+            changed: true,
+        });
+        return;
+    }
     if (req.method === 'POST' &&
         resource === 'work-items' &&
         segments.length === 3 &&

package/dist/src/core/projection-updater.js CHANGED Viewed

@@ -1,6 +1,7 @@
-import { CORRELATION_PRIMARY_CONFLICT_EVENT, CORRELATION_REGISTERED_EVENT, CORRELATION_RETRACTED_EVENT, RETRY_REQUESTED_EVENT, RUN_REQUESTED_EVENT, RUN_CLAIMED_EVENT, RUN_COMPLETED_EVENT, WORKFLOW_SELECTED_EVENT, WORKSPACE_CLEANED_EVENT, } from '../domain/event-types.js';
+import { CORRELATION_PRIMARY_CONFLICT_EVENT, CORRELATION_REGISTERED_EVENT, CORRELATION_RETRACTED_EVENT, RETRY_REQUESTED_EVENT, RUN_REQUESTED_EVENT, RUN_CLAIMED_EVENT, RUN_COMPLETED_EVENT, WORKFLOW_SELECTED_EVENT, WORK_ITEM_DELETED_EVENT, WORK_ITEM_FROZEN_EVENT, WORK_ITEM_UNFROZEN_EVENT, WORKSPACE_CLEANED_EVENT, } from '../domain/event-types.js';
 import { UNRESOLVED_WORK_ITEM_KEY, parseIssueStateRecord } from '../domain/schema.js';
 import { doneRunnerSentinel, stageFromLabels } from '../domain/stages.js';
+import { FROZEN_WORK_ITEM_LABEL } from '../domain/work-item-lifecycle.js';
 import { builtInDefaultWorkflowDefinition, defaultWorkflowName, selectWorkflowForEvent, workflowStageVocabulary, } from '../domain/workflows.js';
 import { isCustomCommandAction } from '../domain/custom-commands.js';
 import { createEventEnvelope } from '../lib/event-log.js';
@@ -353,6 +354,60 @@ async function applyEvent(current, event, ctx, config) {
             },
         });
     }
+    if (event.sourceEventType === WORK_ITEM_DELETED_EVENT) {
+        return parseIssueStateRecord({
+            ...current,
+            context: {
+                ...current.context,
+                deletedAt: event.occurredAt,
+                deletedBy: typeof event.payload.requestedBy === 'string' ? event.payload.requestedBy : 'unknown',
+            },
+            wake: {
+                ...current.wake,
+                sessionId: undefined,
+                sessionCli: undefined,
+                syncedAt: event.ingestedAt,
+                recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+            },
+        });
+    }
+    if (event.sourceEventType === WORK_ITEM_FROZEN_EVENT) {
+        return parseIssueStateRecord({
+            ...current,
+            issue: {
+                ...current.issue,
+                labels: Array.from(new Set([...current.issue.labels, FROZEN_WORK_ITEM_LABEL])),
+            },
+            context: {
+                ...current.context,
+                frozenAt: event.occurredAt,
+                frozenBy: typeof event.payload.requestedBy === 'string' ? event.payload.requestedBy : 'unknown',
+            },
+            wake: {
+                ...current.wake,
+                syncedAt: event.ingestedAt,
+                recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+            },
+        });
+    }
+    if (event.sourceEventType === WORK_ITEM_UNFROZEN_EVENT) {
+        const nextContext = { ...current.context };
+        delete nextContext.frozenAt;
+        delete nextContext.frozenBy;
+        return parseIssueStateRecord({
+            ...current,
+            issue: {
+                ...current.issue,
+                labels: current.issue.labels.filter((label) => label !== FROZEN_WORK_ITEM_LABEL),
+            },
+            context: nextContext,
+            wake: {
+                ...current.wake,
+                syncedAt: event.ingestedAt,
+                recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+            },
+        });
+    }
     if (event.sourceEventType === WORKSPACE_CLEANED_EVENT) {
         return parseIssueStateRecord({
             ...current,

package/dist/src/core/tick-runner.js CHANGED Viewed

@@ -9,6 +9,7 @@ import { CORRELATION_REGISTERED_EVENT, CORRELATION_PRIMARY_CONFLICT_EVENT, PR_AU
 import { parseRunnerArtifacts, parseRunnerResult } from '../domain/schema.js';
 import { maxConfiguredRunnerTimeoutMs, resolveRunnerRouting } from '../domain/runner-routing.js';
 import { awaitingApprovalRunnerSentinel, stageLabelForStage } from '../domain/stages.js';
+import { isWorkItemDeleted, isWorkItemRunnable } from '../domain/work-item-lifecycle.js';
 import { isMeaningfulRuntimeEvent } from '../domain/runtime-events.js';
 import { chooseAction as chooseWorkflowAction, entryStage as workflowEntryStage, isKnownWorkflowStage, workflowChangedBlockReason, workflowForProjection, workflowLabelForWorkflowName, workflowNameForProjection, } from '../domain/workflows.js';
 import { createEventEnvelope } from '../lib/event-log.js';
@@ -571,7 +572,7 @@ export function createTickRunner(deps) {
         const seen = new Set();
         const watch = [];
         for (const projection of projections) {
-            if (projection.issue.state !== 'open') {
+            if (projection.issue.state !== 'open' || isWorkItemDeleted(projection)) {
                 continue;
             }
             for (const resource of projection.correlatedResources) {
@@ -593,7 +594,7 @@ export function createTickRunner(deps) {
             }
         }
         for (const projection of projections) {
-            if (activeRunWorkItemKeys.has(projection.workItemKey)) {
+            if (!isWorkItemRunnable(projection) || activeRunWorkItemKeys.has(projection.workItemKey)) {
                 continue;
             }
             const statusLabel = statusLabelForStage(projection.wake.stage);
@@ -929,7 +930,7 @@ export function createTickRunner(deps) {
             // other path that excludes closed issues. Without this, a closed issue
             // whose last-seen local status matches `watcher.while.status` (e.g.
             // awaiting-approval) re-fires its watcher workflow every tick forever.
-            if (projection.issue.state !== 'open')
+            if (projection.issue.state !== 'open' || !isWorkItemRunnable(projection))
                 continue;
             const parentWorkflow = workflowForProjection(projection, deps.config);
             if (parentWorkflow === null)
@@ -1075,7 +1076,8 @@ export function createTickRunner(deps) {
             if (await parkConfigDriftedProjections(projections)) {
                 return { status: 'processed' };
             }
-            let candidate = projections.find((issue) => policy.resolveNextEligibleAction(issue, deps.config) !== null);
+            let candidate = projections.find((issue) => isWorkItemRunnable(issue) &&
+                policy.resolveNextEligibleAction(issue, deps.config) !== null);
             const watcherDispatch = candidate === undefined ? await nextWatcherDispatch(projections, tickStartedAt) : null;
             candidate ??= watcherDispatch?.projection;
             let watcherStateKeyForRun;

package/dist/src/domain/event-types.js CHANGED Viewed

@@ -15,6 +15,9 @@ export const RUN_CLAIMED_EVENT = 'wake.run.claimed';
 export const RUN_COMPLETED_EVENT = 'wake.run.completed';
 export const WORKFLOW_SELECTED_EVENT = 'wake.workflow.selected';
 export const WORK_ITEM_CREATED_EVENT = 'wake.workitem.created';
+export const WORK_ITEM_DELETED_EVENT = 'wake.workitem.deleted';
+export const WORK_ITEM_FROZEN_EVENT = 'wake.workitem.frozen';
+export const WORK_ITEM_UNFROZEN_EVENT = 'wake.workitem.unfrozen';
 export const WORKSPACE_CLEANED_EVENT = 'wake.workspace.cleaned';
 export const WORKSPACE_CLEANUP_FAILED_EVENT = 'wake.workspace.cleanup-failed';
 export const wakeEventTypeValues = [
@@ -35,6 +38,9 @@ export const wakeEventTypeValues = [
     RUN_COMPLETED_EVENT,
     WORKFLOW_SELECTED_EVENT,
     WORK_ITEM_CREATED_EVENT,
+    WORK_ITEM_DELETED_EVENT,
+    WORK_ITEM_FROZEN_EVENT,
+    WORK_ITEM_UNFROZEN_EVENT,
     WORKSPACE_CLEANED_EVENT,
     WORKSPACE_CLEANUP_FAILED_EVENT,
 ];
@@ -124,6 +130,21 @@ export const wakeEventTypeDefinitions = [
         description: 'Mints a Wake work item identity before resource correlation is registered.',
         payloadShape: '{}',
     },
+    {
+        type: WORK_ITEM_DELETED_EVENT,
+        description: 'Soft-deletes a work item and excludes it from board display and execution.',
+        payloadShape: '{ requestedBy }',
+    },
+    {
+        type: WORK_ITEM_FROZEN_EVENT,
+        description: 'Marks a work item as frozen so runner ticks will not execute it.',
+        payloadShape: '{ requestedBy }',
+    },
+    {
+        type: WORK_ITEM_UNFROZEN_EVENT,
+        description: 'Clears a work item freeze so runner ticks may execute it again.',
+        payloadShape: '{ requestedBy }',
+    },
     {
         type: WORKSPACE_CLEANED_EVENT,
         description: 'Records successful cleanup of a closed issue workspace.',

package/dist/src/domain/schema.js CHANGED Viewed

@@ -70,12 +70,6 @@ export const runtimeEventSchema = z.object({
 });
 export const defaultAgentIdentity = 'Wake';
 export const defaultSmokePrompt = `This is ${defaultAgentIdentity}, reply with "hi ${defaultAgentIdentity} only"`;
-const modelOverridesSchema = z
-    .object({
-    default: z.string().optional(),
-})
-    .catchall(z.string())
-    .default({});
 const claudeEffortSchema = z.enum(['low', 'medium', 'high', 'xhigh', 'max']);
 const codexReasoningEffortSchema = z.enum(['low', 'medium', 'high']);
 const cursorModeSchema = z.enum(['ask', 'agent']);
@@ -96,7 +90,6 @@ const claudeRunnerSettingsSchema = z.object({
         enabled: z.boolean().default(false),
     })
         .default({ enabled: false }),
-    models: modelOverridesSchema.default({ default: 'haiku', implement: 'claude-sonnet-4-6' }),
     effort: claudeEffortSchema.optional(),
 });
 const codexRunnerSettingsSchema = z.object({
@@ -109,7 +102,6 @@ const codexRunnerSettingsSchema = z.object({
         .int()
         .positive()
         .default(30 * 60 * 1000),
-    models: modelOverridesSchema.default({ default: 'gpt-5.5', implement: 'gpt-5.5' }),
     reasoningEffort: codexReasoningEffortSchema.optional(),
 });
 const fakeRunnerEntrySchema = z.object({
@@ -132,7 +124,6 @@ const cursorRunnerSettingsSchema = z.object({
         .int()
         .positive()
         .default(30 * 60 * 1000),
-    models: modelOverridesSchema.default({ default: 'composer-2.5', implement: 'composer-2.5' }),
     defaultMode: cursorModeSchema.optional(),
 });
 const cursorRunnerEntrySchema = cursorRunnerSettingsSchema.extend({
@@ -672,7 +663,6 @@ const wakeConfigBaseSchema = z.object({
             smokePrompt: defaultSmokePrompt,
             timeoutMs: 30 * 60 * 1000,
             remoteControl: { enabled: false },
-            models: { default: 'haiku' },
         },
         'claude-opus': {
             kind: 'claude',
@@ -684,7 +674,6 @@ const wakeConfigBaseSchema = z.object({
             smokePrompt: defaultSmokePrompt,
             timeoutMs: 30 * 60 * 1000,
             remoteControl: { enabled: false },
-            models: { default: 'claude-opus-4-8' },
         },
         'codex-mini': {
             kind: 'codex',
@@ -693,7 +682,6 @@ const wakeConfigBaseSchema = z.object({
             smokeModel: 'gpt-5.4-mini',
             smokePrompt: defaultSmokePrompt,
             timeoutMs: 30 * 60 * 1000,
-            models: { default: 'gpt-5.4-mini', implement: 'gpt-5.4-mini' },
         },
         'codex-flagship': {
             kind: 'codex',
@@ -702,7 +690,6 @@ const wakeConfigBaseSchema = z.object({
             smokeModel: 'gpt-5.4-mini',
             smokePrompt: defaultSmokePrompt,
             timeoutMs: 30 * 60 * 1000,
-            models: { default: 'gpt-5.5', implement: 'gpt-5.5' },
         },
         'cursor-composer': {
             kind: 'cursor',
@@ -711,7 +698,6 @@ const wakeConfigBaseSchema = z.object({
             smokeModel: 'auto',
             smokePrompt: defaultSmokePrompt,
             timeoutMs: 30 * 60 * 1000,
-            models: { default: 'composer-2.5', implement: 'composer-2.5' },
         },
     }),
     tiers: z.record(z.string(), z.array(z.string().min(1)).min(1)).default({

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

@@ -0,0 +1,10 @@
+export const FROZEN_WORK_ITEM_LABEL = 'wake:frozen';
+export function isWorkItemDeleted(item) {
+    return typeof item.context.deletedAt === 'string';
+}
+export function isWorkItemFrozen(item) {
+    return typeof item.context.frozenAt === 'string';
+}
+export function isWorkItemRunnable(item) {
+    return !isWorkItemDeleted(item) && !isWorkItemFrozen(item);
+}

package/dist/src/version.js CHANGED Viewed

@@ -124,4 +124,4 @@ export function resolveWakeVersion(options = {}) {
     }
     return '0.1.0-dev';
 }
-export const wakeVersion = "g903477c";
+export const wakeVersion = "gf13e2d4";

package/package.json CHANGED Viewed

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