@atolis-hq/wake 0.2.33 → 0.2.35

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

@@ -172,6 +172,9 @@ export function createClaudeRunner(options) {
                 projection: input.projection,
                 mode: isResume ? 'resume' : 'start',
                 config: input.config,
+                ...(input.promptContextOverrides === undefined
+                    ? {}
+                    : { contextOverrides: input.promptContextOverrides }),
                 ...(input.mergeConflictDetected === true ? { mergeConflictDetected: true } : {}),
                 ...(input.upstreamChanges === undefined ? {} : { upstreamChanges: input.upstreamChanges }),
             });

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

@@ -215,7 +215,14 @@ export function createCodexRunner(options) {
                 ...(input.workspaceMode === undefined ? {} : { workspaceMode: input.workspaceMode }),
                 ...(input.mergeConflictDetected === true ? { mergeConflictDetected: true } : {}),
                 ...(input.upstreamChanges === undefined ? {} : { upstreamChanges: input.upstreamChanges }),
-                ...(toolCapabilityNote !== undefined ? { contextOverrides: { toolCapabilityNote } } : {}),
+                ...(toolCapabilityNote !== undefined || input.promptContextOverrides !== undefined
+                    ? {
+                        contextOverrides: {
+                            ...input.promptContextOverrides,
+                            ...(toolCapabilityNote === undefined ? {} : { toolCapabilityNote }),
+                        },
+                    }
+                    : {}),
             });
             const model = resolveModel({
                 action: input.action,

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

@@ -173,7 +173,14 @@ export function createCursorRunner(options) {
                 ...(input.workspaceMode === undefined ? {} : { workspaceMode: input.workspaceMode }),
                 ...(input.mergeConflictDetected === true ? { mergeConflictDetected: true } : {}),
                 ...(input.upstreamChanges === undefined ? {} : { upstreamChanges: input.upstreamChanges }),
-                ...(toolCapabilityNote !== undefined ? { contextOverrides: { toolCapabilityNote } } : {}),
+                ...(toolCapabilityNote !== undefined || input.promptContextOverrides !== undefined
+                    ? {
+                        contextOverrides: {
+                            ...input.promptContextOverrides,
+                            ...(toolCapabilityNote === undefined ? {} : { toolCapabilityNote }),
+                        },
+                    }
+                    : {}),
             });
             const model = resolveModel({ action: input.action, settings: options.settings });
             const cwd = input.workspacePath ?? options.cwd;

package/dist/src/adapters/runner/stage-prompt.js

@@ -1,4 +1,5 @@
 import { defaultAgentIdentity } from '../../domain/schema.js';
+import { alwaysManualIgnoredLabels } from '../../core/policy-engine.js';
 import { chooseAction, workflowForProjection } from '../../domain/workflows.js';
 import { branchNameForIssue } from '../git/git-workspace-manager.js';
 import { loadPromptTemplate, renderPromptTemplate } from './prompt-templates.js';
@@ -165,6 +166,17 @@ export async function buildStagePrompt(input) {
         isStart: mode === 'start',
         isResume: mode === 'resume',
     };
+    if (input.action === 'triage-assign' && input.config !== undefined) {
+        const ignoredLabels = [
+            ...new Set([
+                ...alwaysManualIgnoredLabels,
+                ...input.config.sources.github.policy.ignoredLabels,
+            ]),
+        ];
+        context.triageIgnoredLabels = ignoredLabels;
+        context.triageIgnoredLabelsJson = JSON.stringify(ignoredLabels);
+        context.triageReposJson = JSON.stringify(input.config.sources.github.repos);
+    }
     if (resolvedWorkspaceMode === 'branch') {
         context.branch = branchNameForIssue(input.projection.issue.number);
     }

package/dist/src/core/policy-engine.js

@@ -1,6 +1,7 @@
 import { awaitingApprovalRunnerSentinel, failedRunnerSentinel } from '../domain/stages.js';
 import { resolveCustomCommand } from '../domain/custom-commands.js';
 import { builtInDefaultWorkflowDefinition, chooseAction as chooseWorkflowAction, isKnownWorkflowStage, selectWorkflowForEvent, workflowForProjection, } from '../domain/workflows.js';
+export const alwaysManualIgnoredLabels = ['security', 'wake:manual', 'wake:always-manual'];
 function isAwaitingApproval(issue) {
     const context = issue.context;
     return context.lastRunSentinel === awaitingApprovalRunnerSentinel;
@@ -36,7 +37,8 @@ function labelsAndAssigneesQualify(input) {
     if (input.requiredLabels.some((label) => !labels.has(label))) {
         return false;
     }
-    if (input.ignoredLabels.some((label) => labels.has(label))) {
+    const ignoredLabels = new Set([...input.ignoredLabels, ...alwaysManualIgnoredLabels]);
+    if ([...ignoredLabels].some((label) => labels.has(label))) {
         return false;
     }
     if (input.requiredAssignees.length > 0 &&
@@ -67,6 +69,9 @@ export function createPolicyEngine() {
             if (issue.issue.state !== 'open') {
                 return false;
             }
+            if (issue.issue.labels.some((label) => alwaysManualIgnoredLabels.includes(label))) {
+                return false;
+            }
             const context = issue.context;
             if (config.workflowSelectors.length > 0) {
                 return typeof context.workflow === 'string';
@@ -240,6 +245,10 @@ export function createPolicyEngine() {
                 return false;
             }
             const kind = resourceUri.split(':')[1];
+            if (kind === 'schedule') {
+                const workflow = unresolved.payload.workflow;
+                return typeof workflow === 'string' && config.workflows[workflow] !== undefined;
+            }
             if (config.workflowSelectors.length > 0) {
                 return selectWorkflowForEvent(unresolved, config) !== null;
             }

package/dist/src/core/scheduled-workflow-source.js

@@ -0,0 +1,199 @@
+import { createUnkeyedEventEnvelope } from '../lib/event-log.js';
+import { buildResourceUri } from '../domain/resource-uri.js';
+import { readJsonFile, writeJsonFile } from '../lib/json-file.js';
+import { createWakePaths } from '../lib/paths.js';
+import { isMissingPathError } from '../lib/state-health.js';
+const syntheticRepo = 'wake/internal';
+const syntheticIssueNumber = 1;
+function parseCronField(raw, min, max) {
+    const allowed = new Set();
+    for (const part of raw.split(',')) {
+        const trimmed = part.trim();
+        if (trimmed.length === 0) {
+            throw new Error(`invalid cron field "${raw}"`);
+        }
+        const stepMatch = /^(.*)\/(\d+)$/.exec(trimmed);
+        const base = stepMatch?.[1] ?? trimmed;
+        const step = stepMatch === null ? 1 : Number(stepMatch[2]);
+        if (!Number.isInteger(step) || step <= 0) {
+            throw new Error(`invalid cron step "${trimmed}"`);
+        }
+        const range = base === '*'
+            ? [min, max]
+            : (() => {
+                const match = /^(\d+)(?:-(\d+))?$/.exec(base);
+                if (match === null) {
+                    throw new Error(`invalid cron segment "${trimmed}"`);
+                }
+                const start = Number(match[1]);
+                const end = match[2] === undefined ? start : Number(match[2]);
+                if (start < min || end > max || start > end) {
+                    throw new Error(`cron segment "${trimmed}" is outside ${min}-${max}`);
+                }
+                return [start, end];
+            })();
+        for (let value = range[0]; value <= range[1]; value += step) {
+            allowed.add(value);
+        }
+    }
+    return { matches: (value) => allowed.has(value) };
+}
+function parseCron(cron) {
+    const fields = cron.trim().split(/\s+/);
+    if (fields.length !== 5) {
+        throw new Error(`cron schedule must have five fields: ${cron}`);
+    }
+    return [
+        parseCronField(fields[0], 0, 59),
+        parseCronField(fields[1], 0, 23),
+        parseCronField(fields[2], 1, 31),
+        parseCronField(fields[3], 1, 12),
+        parseCronField(fields[4], 0, 6),
+    ];
+}
+function matchesCron(date, cron) {
+    return (cron[0].matches(date.getUTCMinutes()) &&
+        cron[1].matches(date.getUTCHours()) &&
+        cron[2].matches(date.getUTCDate()) &&
+        cron[3].matches(date.getUTCMonth() + 1) &&
+        cron[4].matches(date.getUTCDay()));
+}
+function floorToMinute(date) {
+    const copy = new Date(date);
+    copy.setUTCSeconds(0, 0);
+    return copy;
+}
+function previousMatchingSlot(input) {
+    const parsed = parseCron(input.cron);
+    const slot = floorToMinute(input.now);
+    const afterMs = input.after === undefined ? undefined : Date.parse(input.after);
+    const lookbackMinutes = 366 * 24 * 60;
+    for (let checked = 0; checked < lookbackMinutes; checked += 1) {
+        const slotIso = slot.toISOString();
+        if (afterMs !== undefined && slot.getTime() <= afterMs) {
+            return null;
+        }
+        if (matchesCron(slot, parsed)) {
+            return slotIso;
+        }
+        slot.setUTCMinutes(slot.getUTCMinutes() - 1);
+    }
+    return null;
+}
+function triggerStateFile(wakeRoot, workflow) {
+    return `${createWakePaths(wakeRoot).dataRoot}/triggers/${workflow}.json`;
+}
+async function readTriggerState(wakeRoot, workflow) {
+    try {
+        const raw = await readJsonFile(triggerStateFile(wakeRoot, workflow));
+        if (raw === null || typeof raw !== 'object') {
+            return null;
+        }
+        const record = raw;
+        return record.schemaVersion === 1 &&
+            record.workflow === workflow &&
+            typeof record.lastFiredSlot === 'string' &&
+            typeof record.updatedAt === 'string'
+            ? {
+                schemaVersion: 1,
+                workflow,
+                lastFiredSlot: record.lastFiredSlot,
+                updatedAt: record.updatedAt,
+            }
+            : null;
+    }
+    catch (error) {
+        if (isMissingPathError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+function scheduledEventId(workflow, slot) {
+    return `scheduled-workflow-${workflow}-${slot.replace(/[^a-z0-9]+/gi, '-')}`;
+}
+function scheduledResourceUri(workflow, slot) {
+    return buildResourceUri('wake', 'schedule', `${workflow}@${slot}`);
+}
+function syntheticTicket(input) {
+    const eventId = scheduledEventId(input.workflow, input.slot);
+    const resourceUri = scheduledResourceUri(input.workflow, input.slot);
+    const url = `https://wake.local/schedules/${encodeURIComponent(input.workflow)}/${encodeURIComponent(input.slot)}`;
+    return createUnkeyedEventEnvelope({
+        eventId,
+        streamScope: 'global-intake',
+        direction: 'inbound',
+        sourceSystem: 'wake',
+        sourceEventType: 'ticket.upsert',
+        sourceRefs: {
+            repo: syntheticRepo,
+            issueNumber: syntheticIssueNumber,
+            sourceUrl: url,
+            resourceUri,
+        },
+        occurredAt: input.slot,
+        ingestedAt: input.now,
+        trigger: 'immediate',
+        payload: {
+            ticket: {
+                repo: syntheticRepo,
+                number: syntheticIssueNumber,
+                title: `Scheduled workflow: ${input.workflow}`,
+                body: `Wake fired scheduled workflow "${input.workflow}" for cron slot ${input.slot}.`,
+                labels: ['wake:scheduled-workflow', `wake:workflow.${input.workflow}`],
+                assignees: [],
+                isPullRequest: false,
+                state: 'open',
+                url,
+                createdAt: input.slot,
+                updatedAt: input.slot,
+            },
+            workflow: input.workflow,
+            trigger: {
+                kind: 'schedule',
+                slot: input.slot,
+                idempotencyKey: eventId,
+            },
+            providerEventType: 'wake.schedule.fired',
+        },
+        derivedHints: {
+            workflow: input.workflow,
+        },
+    });
+}
+export function createScheduledWorkflowSource(deps) {
+    return {
+        async pollEvents() {
+            const events = [];
+            const now = deps.now();
+            const nowIso = now.toISOString();
+            for (const [workflow, definition] of Object.entries(deps.config.workflows)) {
+                const cron = definition.trigger?.schedule?.cron;
+                if (cron === undefined) {
+                    continue;
+                }
+                const state = await readTriggerState(deps.config.paths.wakeRoot, workflow);
+                const slot = previousMatchingSlot({
+                    cron,
+                    now,
+                    ...(state?.lastFiredSlot === undefined ? {} : { after: state.lastFiredSlot }),
+                });
+                if (slot === null) {
+                    continue;
+                }
+                const eventId = scheduledEventId(workflow, slot);
+                if ((await deps.stateStore.readEventEnvelope(eventId)) !== null) {
+                    await writeJsonFile(triggerStateFile(deps.config.paths.wakeRoot, workflow), {
+                        schemaVersion: 1,
+                        workflow,
+                        lastFiredSlot: slot,
+                        updatedAt: nowIso,
+                    });
+                    continue;
+                }
+                events.push(syntheticTicket({ workflow, slot, now: nowIso }));
+            }
+            return events;
+        },
+    };
+}

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

@@ -602,6 +602,14 @@ export function createTickRunner(deps) {
                     runId,
                     routing,
                     workspaceMode,
+                    ...(action === 'triage-assign'
+                        ? {
+                            promptContextOverrides: {
+                                triageCapacityAvailable: true,
+                                triageWipCapDescription: 'Wake has no active running work item at triage start; do not assign more than one issue.',
+                            },
+                        }
+                        : {}),
                     ...(workspacePath === undefined ? {} : { workspacePath }),
                     ...(mergeConflictDetected ? { mergeConflictDetected: true } : {}),
                     ...(upstreamChanges === undefined ? {} : { upstreamChanges }),

package/dist/src/domain/schema.js

@@ -375,11 +375,18 @@ const workflowStageSchema = stageRouteSchema.extend({
     workspace: workflowWorkspaceSchema,
     onDone: identifierSchema,
 });
+const workflowTriggerScheduleSchema = z.object({
+    cron: z.string().min(1),
+});
+const workflowTriggerSchema = z.object({
+    schedule: workflowTriggerScheduleSchema.optional(),
+});
 const customCommandSchema = stageRouteSchema.extend({
     workspace: workflowWorkspaceSchema.default('read-only'),
 });
 const workflowDefinitionSchema = z.object({
     entryStage: identifierSchema.optional(),
+    trigger: workflowTriggerSchema.optional(),
     stages: z.record(identifierSchema, workflowStageSchema),
 });
 const workflowSelectorMatchSchema = z
@@ -605,6 +612,21 @@ const wakeConfigBaseSchema = z.object({
                 },
             },
         },
+        triage: {
+            trigger: {
+                schedule: {
+                    cron: '*/10 * * * *',
+                },
+            },
+            stages: {
+                assign: {
+                    action: 'triage-assign',
+                    workspace: 'none',
+                    tier: 'light',
+                    onDone: 'done',
+                },
+            },
+        },
     }),
     workflowSelectors: z.array(workflowSelectorSchema).default([]),
     commands: z.record(identifierSchema, customCommandSchema).default({

package/dist/src/domain/workflows.js

@@ -102,6 +102,10 @@ function selectorMatches(selector, input) {
     return true;
 }
 export function selectWorkflowForEvent(event, config) {
+    const hintedWorkflow = event.payload.workflow;
+    if (typeof hintedWorkflow === 'string' && config.workflows[hintedWorkflow] !== undefined) {
+        return hintedWorkflow;
+    }
     const input = workflowSelectorInputFromEvent(event);
     const selector = config.workflowSelectors.find((candidate) => selectorMatches(candidate, input));
     return selector?.workflow ?? null;

package/dist/src/main.js

@@ -31,6 +31,7 @@ import { loadWakeConfig } from './config/load-config.js';
 import { createActiveRunRecovery } from './core/active-run-recovery.js';
 import { createControlPlane } from './core/control-plane.js';
 import { createOutboundSinkRouter, createWorkSourceFanIn } from './core/sink-router.js';
+import { createScheduledWorkflowSource } from './core/scheduled-workflow-source.js';
 import { createTickRunner } from './core/tick-runner.js';
 import { systemClock } from './lib/clock.js';
 import { createDetachedProcessLogSink } from './lib/detached-process-logging.js';
@@ -521,6 +522,14 @@ export async function buildRuntime(args) {
         })
         : null;
     const workSource = createWorkSourceFanIn([
+        {
+            source: 'wake-schedule',
+            pollEvents: createScheduledWorkflowSource({
+                config,
+                stateStore,
+                now: () => systemClock.now(),
+            }).pollEvents,
+        },
         {
             source: sourceName,
             pollEvents: ticketingSystem.pollEvents,

package/dist/src/version.js

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

package/package.json

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

package/prompts/triage-assign.md

@@ -0,0 +1,33 @@
+---
+stage: assign
+permissionMode: acceptEdits
+allowedTools: Bash(gh *), Bash(jq *), Read
+extraArgs:
+maxTurns: 30
+skipApproval: true
+---
+
+You are Wake, in the TRIAGE ASSIGN stage for {{workItemKey}}.
+
+This stage may inspect the broad GitHub backlog and assign at most one issue to Wake.
+{{toolCapabilityNote}}
+
+Wake-side guardrails for this run:
+
+- Capacity available: {{triageCapacityAvailable}}
+- Do not assign more than one issue.
+- Do not inspect or assign issues carrying any of these always-manual labels:
+  {{triageIgnoredLabelsJson}}
+- Configured repositories:
+  {{triageReposJson}}
+
+Use `gh issue list` and `gh issue view` only against the configured repositories.
+Filter out every always-manual label in the GitHub query before viewing candidate
+details. If no suitable issue remains, report DONE without assigning anything.
+
+When you choose a candidate, assign it to the authenticated Wake GitHub user with
+`gh issue edit <number> --repo <owner/repo> --add-assignee @me`.
+
+Wake will provide the schedule trigger item below in a delimited untrusted data
+block. It is an audit record, not the backlog to triage.
+