agents-relay 1.0.177 → 2.0.1

package/dist/relayd.js

@@ -10,8 +10,12 @@ import { NatsEventBus } from './events.js';
 import { RepositoryWorkerPool, aggregateManagedGitHubJobs } from './pool.js';
 import { Reconciler } from './reconciler.js';
 import { dashboardManagedJobs, GitHubStore, InMemoryStore, loadManagedGitHubPullRequestSnapshotGraphql, withGitHubRequestContext } from './store.js';
+import { ProjectedDurableStore } from './projected-store.js';
+import { discoverLocalRelayStoreSnapshots, SQLiteRelayStore } from './relay-store.js';
 import { githubAuthContext } from './github-auth.js';
 import { dashboardJobAction, isEntrypoint, runtimePlanner, runtimeReviewer, startService, SERVICE_DEFAULTS } from './cli.js';
+import { applyJobActivateAction } from './job-actions.js';
+import { applyOrchestratorCompleteAction } from './task-actions.js';
 import { dashboardJobSetState, dashboardTaskAction, dashboardTaskSetState } from './dashboard-actions.js';
 import { codexAndZaiUsageRegistry } from './usage.js';
 import { defaultWorkspaceRoot, discoverWorkspaceRepositories, resolveManagedProjectPath, resolveRepositoryProjectPath } from './workspace.js';
@@ -19,8 +23,14 @@ import { deriveJobRuntimeStatus } from './runtime-status.js';
 import { decisionMode, LayaCliDecisionEngine } from './decision.js';
 import { JsonlDecisionAuditStore } from './decision-audit.js';
 import { summarizeRuntime } from './runtime-summary.js';
-import { runScheduledBucket } from './scheduled-jobs.js';
-import { scheduleBucket } from './scheduler.js';
+export async function overlayOperationalOverviews(overviews, storeFor) {
+    return await Promise.all(overviews.map(async (item) => {
+        const store = storeFor(item.job.repository, item.job.prNumber);
+        await store.hydrate?.(item.job);
+        const job = await store.load(item.job.id);
+        return { ...item, job };
+    }));
+}
 const PR_REFRESH_COALESCE_MS = 1000;
 export const SCHEDULE_HEARTBEAT_MS = 600_000;
 export function dueScheduledOverviews(overviews, now = new Date()) {
@@ -40,6 +50,7 @@ Options:
   --port PORT             Dashboard port (default: 8787)
   --concurrency N         Maximum concurrent workers (default: 4)
   --interval MS           Recovery interval
+  --projection-ms MS      GitHub projection flush interval (default: 1000)
   --events nats            Enable event wakeups
 
 Legacy single-job mode also accepts --repo OWNER/REPO --pr NUMBER --id JOB_ID.
@@ -109,6 +120,20 @@ export async function runDaemon(argv) {
     let cachedOverviews = [];
     const githubReadPaths = { workspaceScans: 0, prRefreshes: 0, prRefreshesByTrigger: {}, prRefreshCoalesced: 0, prRefreshCoalescedByTrigger: {} };
     let dormantProbeIndex = 0;
+    const relayStores = new Map();
+    const projectionWriters = new Map();
+    const runtimeStore = (repository, prNumber, seed) => {
+        const key = `${repository}#${prNumber}`;
+        let relay = relayStores.get(key);
+        if (!relay) {
+            relay = new SQLiteRelayStore(join(homedir(), '.agents-relay', 'stores', `${repository.replace('/', '_')}-${prNumber}.db`));
+            relayStores.set(key, relay);
+        }
+        const github = new GitHubStore(client, repository, prNumber, trusted, seed);
+        const projected = new ProjectedDurableStore(relay, github, seed ?? null, (relatedRepository, relatedPrNumber) => runtimeStore(relatedRepository, relatedPrNumber));
+        projectionWriters.set(key, projected.projection);
+        return projected;
+    };
     const makeReconciler = (store, maxConcurrent) => new Reconciler(store, { owner: `relayd-${process.pid}`, maxConcurrent, leaseMs: Number(value(argv, '--lease-ms', '300000')), adapters: [new CodexAdapter(value(argv, '--codex', 'codex')), new ChatGptAdapter()], continuations: [new CodexThreadContinuation(value(argv, '--codex', 'codex')), new CommandContinuation(), new WebhookContinuation()], planner: runtimePlanner(argv), usageSnapshotProvider: () => usageRegistry.snapshot(), runtimeSummaryProvider: () => ({ chatgptRunning: summarizeRuntime(cachedOverviews.map(item => item.job)).workers.chatgpt }), decisionEngine: new LayaCliDecisionEngine(), decisionMode: decisionMode(), decisionAuditStore, eventBus: bus, reviewer: runtimeReviewer(), projectPathForJob: async (job) => resolveRepositoryProjectPath(repositoryPaths.get(job.repository) ?? await resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot), job.projectPath) });
     if (repositories.length === 0)
         throw new Error(`No Git repositories with GitHub origins found under ${normalized.workspaceRoot ?? defaultWorkspaceRoot()}`);
@@ -120,7 +145,7 @@ export async function runDaemon(argv) {
             cachedOverviews = parsed;
     }
     catch { /* first run or invalid cache */ }
-    const refreshAll = async (full = false, failOnError = false) => {
+    const refreshAll = async (full = false) => {
         if (client.rateLimitStatus().limited)
             return cachedOverviews;
         const scanRepositories = full ? repositories : recoveryScanRepositories(repositories, cachedOverviews, dormantProbeIndex++);
@@ -130,7 +155,8 @@ export async function runDaemon(argv) {
             githubReadPaths.workspaceScans += 1;
             const refreshed = await withGitHubRequestContext(client, 'relayd.workspace-refresh', () => aggregateManagedGitHubJobs(client, scanRepositories, trusted));
             const scanned = new Set(scanRepositories);
-            cachedOverviews = dashboardManagedJobs([...cachedOverviews.filter(item => !scanned.has(item.job.repository)), ...refreshed]);
+            const merged = dashboardManagedJobs([...cachedOverviews.filter(item => !scanned.has(item.job.repository)), ...refreshed]);
+            cachedOverviews = await overlayOperationalOverviews(merged, (repository, prNumber) => runtimeStore(repository, prNumber));
             try {
                 await mkdir(cacheDirectory, { recursive: true });
                 await writeFile(cacheFile, JSON.stringify(cachedOverviews), 'utf8');
@@ -139,13 +165,16 @@ export async function runDaemon(argv) {
             return cachedOverviews;
         }
         catch (error) {
-            if (failOnError)
-                throw error;
             process.stderr.write(`warning: workspace job refresh unavailable: ${error instanceof Error ? error.message : String(error)}\n`);
             return cachedOverviews;
         }
     };
-    const overviews = async (forceRefresh = false, _trigger = 'internal.unknown') => forceRefresh ? refreshAll(true) : cachedOverviews;
+    const overviews = async (forceRefresh = false, _trigger = 'internal.unknown') => {
+        if (forceRefresh)
+            return refreshAll(true);
+        cachedOverviews = await overlayOperationalOverviews(cachedOverviews, (repository, prNumber) => runtimeStore(repository, prNumber));
+        return cachedOverviews;
+    };
     const persistCache = async () => {
         try {
             await mkdir(cacheDirectory, { recursive: true });
@@ -176,12 +205,14 @@ export async function runDaemon(argv) {
         const flight = (async () => {
             githubReadPaths.prRefreshes += 1;
             const snapshot = await withGitHubRequestContext(client, `relayd.pr-refresh:${trigger}`, () => loadManagedGitHubPullRequestSnapshotGraphql(client, repository, prNumber, trusted));
+            const operational = await overlayOperationalOverviews(snapshot.overviews, (repo, pr) => runtimeStore(repo, pr, repo === repository && pr === prNumber ? snapshot.seed : null));
             cachedOverviews = cachedOverviews.filter(item => item.job.repository !== repository || item.job.prNumber !== prNumber);
-            cachedOverviews.push(...snapshot.overviews);
+            cachedOverviews.push(...operational);
             cachedOverviews = dashboardManagedJobs(cachedOverviews);
             await persistCache();
-            pullRequestRefreshCache.set(key, { snapshot, completedAt: Date.now() });
-            return snapshot;
+            const operationalSnapshot = { ...snapshot, overviews: operational };
+            pullRequestRefreshCache.set(key, { snapshot: operationalSnapshot, completedAt: Date.now() });
+            return operationalSnapshot;
         })();
         pullRequestRefreshFlights.set(key, flight);
         try {
@@ -193,15 +224,15 @@ export async function runDaemon(argv) {
         }
     };
     const refreshPullRequest = async (repository, prNumber, trigger, options) => (await refreshPullRequestSnapshot(repository, prNumber, trigger, options)).overviews;
-    const pool = new RepositoryWorkerPool(client, repositories, trusted, concurrency, makeReconciler, () => client.rateLimitStatus().limited, (repository, prNumber, trigger) => refreshPullRequestSnapshot(repository, prNumber, trigger));
+    const pool = new RepositoryWorkerPool(client, repositories, trusted, concurrency, makeReconciler, () => client.rateLimitStatus().limited, (repository, prNumber, trigger) => refreshPullRequestSnapshot(repository, prNumber, trigger), (repository, prNumber, seed) => runtimeStore(repository, prNumber, seed));
     const initial = cachedOverviews;
     const fallback = initial[0]?.job;
-    const dashboardStore = fallback ? new GitHubStore(client, fallback.repository, fallback.prNumber, trusted) : new InMemoryStore();
+    const dashboardStore = fallback ? runtimeStore(fallback.repository, fallback.prNumber) : new InMemoryStore();
     const workspaceJobAction = (action) => async (jobId) => {
         const overview = cachedOverviews.find(item => item.job.id === jobId);
         if (!overview)
             throw new Error(`Managed job ${jobId} not found`);
-        const store = new GitHubStore(client, overview.job.repository, overview.job.prNumber, trusted);
+        const store = runtimeStore(overview.job.repository, overview.job.prNumber);
         if (action === 'reconcile') {
             await pool.reconcileTarget(overview.job.repository, overview.job.prNumber, jobId);
             return await store.load(jobId);
@@ -212,23 +243,56 @@ export async function runDaemon(argv) {
         const overview = cachedOverviews.find(item => item.job.id === jobId);
         if (!overview)
             throw new Error(`Managed job ${jobId} not found`);
-        const store = new GitHubStore(client, overview.job.repository, overview.job.prNumber, trusted);
+        const store = runtimeStore(overview.job.repository, overview.job.prNumber);
         const result = await dashboardJobSetState(store)(jobId, state);
         await refreshPullRequest(overview.job.repository, overview.job.prNumber, 'dashboard.job-state', { force: true });
         return result;
     };
+    const workspaceTaskCreate = async (jobId, task) => {
+        const overview = cachedOverviews.find(item => item.job.id === jobId);
+        if (!overview)
+            throw new Error(`Managed job ${jobId} not found`);
+        if (task.jobId !== jobId)
+            throw new Error(`Task ${task.id} belongs to ${task.jobId}, not ${jobId}`);
+        const store = runtimeStore(overview.job.repository, overview.job.prNumber);
+        const job = await store.load(jobId);
+        if (['COMPLETED', 'CANCELLED'].includes(job.state))
+            throw new Error(`Cannot create task on terminal job ${job.id} (${job.state})`);
+        await store.appendTask(task);
+        const refreshed = await store.load(jobId);
+        if (refreshed.state === 'DRAFT') {
+            await applyJobActivateAction(refreshed);
+            await store.saveJob(refreshed);
+        }
+        await pool.reconcileTarget(overview.job.repository, overview.job.prNumber, jobId, 'control.task.create');
+        return await store.load(jobId);
+    };
+    const workspaceTaskComplete = async (jobId, taskId, summary) => {
+        const overview = cachedOverviews.find(item => item.job.id === jobId);
+        if (!overview)
+            throw new Error(`Managed job ${jobId} not found`);
+        const store = runtimeStore(overview.job.repository, overview.job.prNumber);
+        const job = await store.load(jobId);
+        const task = job.tasks.find(item => item.id === taskId);
+        if (!task)
+            throw new Error(`Task ${taskId} not found`);
+        await applyOrchestratorCompleteAction(task, summary);
+        await store.saveTask(task);
+        await pool.reconcileTarget(overview.job.repository, overview.job.prNumber, jobId, 'control.task.complete');
+        return await store.load(jobId);
+    };
     const workspaceTaskAction = (action) => async (jobId, taskId) => {
         const overview = cachedOverviews.find(item => item.job.id === jobId);
         if (!overview)
             throw new Error(`Managed job ${jobId} not found`);
-        const store = new GitHubStore(client, overview.job.repository, overview.job.prNumber, trusted);
+        const store = runtimeStore(overview.job.repository, overview.job.prNumber);
         return await dashboardTaskAction(store, makeReconciler(store, concurrency), action)(jobId, taskId);
     };
     const workspaceTaskSetState = async (jobId, taskId, state) => {
         const overview = cachedOverviews.find(item => item.job.id === jobId);
         if (!overview)
             throw new Error(`Managed job ${jobId} not found`);
-        const store = new GitHubStore(client, overview.job.repository, overview.job.prNumber, trusted);
+        const store = runtimeStore(overview.job.repository, overview.job.prNumber);
         const result = await dashboardTaskSetState(store)(jobId, taskId, state);
         await refreshPullRequest(overview.job.repository, overview.job.prNumber, 'dashboard.task-state', { force: true });
         return result;
@@ -273,13 +337,14 @@ export async function runDaemon(argv) {
         reconcile: workspaceJobAction('reconcile'),
         cancel: workspaceJobAction('cancel'),
         jobSetState: workspaceJobSetState,
+        taskCreate: workspaceTaskCreate,
         taskRetry: workspaceTaskAction('retry'),
         taskCancel: workspaceTaskAction('cancel'),
+        taskComplete: workspaceTaskComplete,
         taskSetState: workspaceTaskSetState,
     });
+    await once(server, 'listening');
     const reconcileSafely = async () => {
-        if (client.rateLimitStatus().limited)
-            return;
         try {
             await pool.reconcile();
         }
@@ -288,37 +353,65 @@ export async function runDaemon(argv) {
         }
     };
     const scheduleHeartbeatSafely = async () => {
-        if (client.rateLimitStatus().limited)
-            return;
         const now = new Date();
         for (const item of dueScheduledOverviews(cachedOverviews, now)) {
-            const repository = item.job.repository;
             try {
-                await runScheduledBucket(client, repository, trusted, { prNumber: item.job.prNumber, jobId: item.job.id, bucket: scheduleBucket(new Date(item.job.schedule.nextRunAt)) }, { reconcile: async () => { await pool.reconcileTarget(repository, item.job.prNumber, item.job.id); }, idle: async () => { } }, now);
+                await pool.scheduleTickSignal(bus, item.job, now);
+            }
+            catch (error) {
+                process.stderr.write(`warning: scheduled heartbeat unavailable for ${item.job.repository}#${item.job.prNumber}: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+        }
+    };
+    const flushProjectionsSafely = async () => {
+        for (const writer of projectionWriters.values()) {
+            try {
+                await writer.flushOnce();
             }
             catch (error) {
-                process.stderr.write(`warning: scheduled heartbeat unavailable for ${repository}#${item.job.prNumber}: ${error instanceof Error ? error.message : String(error)}\n`);
+                process.stderr.write(`warning: GitHub projection flush unavailable: ${error instanceof Error ? error.message : String(error)}\n`);
             }
         }
     };
     const watchdogDefault = webhook ? SERVICE_DEFAULTS.webhookWatchdogMs : SERVICE_DEFAULTS.watchdogMs;
     let interval;
     let scheduleInterval;
+    let projectionInterval;
     const stop = () => { if (interval)
         clearInterval(interval); if (scheduleInterval)
-        clearInterval(scheduleInterval); void stopWatch().finally(() => server.close(() => process.exit(0))); };
+        clearInterval(scheduleInterval); if (projectionInterval)
+        clearInterval(projectionInterval); void stopWatch().finally(() => { for (const store of relayStores.values())
+        store.close(); server.close(() => process.exit(0)); }); };
     process.once('SIGINT', stop);
     process.once('SIGTERM', stop);
-    await once(server, 'listening');
-    const startupItems = await refreshAll(true, true); // void refreshAll(true)
-    await pool.reconcileKnown(startupItems);
-    // Startup recovery must finish before normal polling or scheduled work can run.
+    const localSnapshots = await discoverLocalRelayStoreSnapshots(join(homedir(), '.agents-relay', 'stores'));
+    const knownRepositories = new Set(repositories);
+    const localOverviews = localSnapshots.flatMap(snapshot => {
+        if (!snapshot.facts)
+            return [];
+        return snapshot.jobs.filter(job => knownRepositories.has(job.repository)).map(job => ({
+            job, githubState: snapshot.facts.state, draft: false, mergedAt: null, closedAt: null, publication: null,
+        }));
+    });
+    const byJob = new Map();
+    for (const item of cachedOverviews)
+        byJob.set(item.job.repository + '#' + item.job.prNumber + ':' + item.job.id, item);
+    for (const item of localOverviews)
+        byJob.set(item.job.repository + '#' + item.job.prNumber + ':' + item.job.id, item);
+    cachedOverviews = dashboardManagedJobs([...byJob.values()]);
+    await pool.reconcileKnown(cachedOverviews);
     await scheduleHeartbeatSafely();
-    interval = setInterval(() => void reconcileSafely(), Number(value(argv, '--interval', String(watchdogDefault))));
+    await flushProjectionsSafely();
+    interval = setInterval(() => void reconcileSafely().finally(flushProjectionsSafely), Number(value(argv, '--interval', String(watchdogDefault))));
     interval.unref();
+    projectionInterval = setInterval(() => void flushProjectionsSafely(), Number(value(argv, '--projection-ms', String(SERVICE_DEFAULTS.projectionFlushMs))));
+    projectionInterval.unref();
     scheduleInterval = setInterval(() => void scheduleHeartbeatSafely(), SCHEDULE_HEARTBEAT_MS);
     scheduleInterval.unref();
     console.log('Dashboard listening; repository worker pool active');
+    void refreshAll(true)
+        .then(items => pool.reconcileKnown(items))
+        .catch(error => process.stderr.write('warning: startup remote refresh unavailable: ' + (error instanceof Error ? error.message : String(error)) + '\n'));
 }
 if (isEntrypoint(import.meta.url))
     runDaemon(process.argv.slice(2)).catch(error => { console.error(error instanceof Error ? error.message : String(error)); process.exitCode = 1; });

package/dist/runtime-status.js

@@ -2,7 +2,8 @@ function isSuperseded(task) {
     return task.state === 'CANCELLED' && typeof task.error === 'string' && task.error.startsWith('Superseded ');
 }
 export function implementationTasks(job) {
-    return job.tasks.filter(task => task.agentName !== 'reviewer'
+    return job.tasks.filter(task => task.kind !== 'planner'
+        && task.agentName !== 'reviewer'
         && task.agentName !== 'troubleshooter'
         && !isSuperseded(task)
         && task.state !== 'UNBLOCKED');

package/dist/scheduled-jobs.js

@@ -1,49 +1,58 @@
 import { GitHubStore } from './store.js';
 import { nextScheduleRun, scheduleBucket } from './scheduler.js';
-async function refresh(client, repository, trustedAuthors, ref) {
-    const store = new GitHubStore(client, repository, ref.prNumber, trustedAuthors);
+import { dispatchScheduledRun } from './workflow/scheduled-run-v2.js';
+async function refresh(client, repository, trustedAuthors, ref, storeFactory) {
+    const store = storeFactory ? storeFactory() : new GitHubStore(client, repository, ref.prNumber, trustedAuthors);
     return await store.load(ref.jobId);
 }
-export async function runScheduledBucket(client, repository, trustedAuthors, ref, engine, now = new Date()) {
-    let job = await refresh(client, repository, trustedAuthors, ref);
+export async function runScheduledBucket(client, repository, trustedAuthors, ref, engine, now = new Date(), storeFactory) {
+    let job = await refresh(client, repository, trustedAuthors, ref, storeFactory);
     const schedule = job.schedule;
     if (!schedule)
-        throw new Error(`Scheduled job ${job.id} has no schedule metadata`);
+        throw new Error('Scheduled job ' + job.id + ' has no schedule metadata');
     const slot = new Date(schedule.nextRunAt);
-    if (scheduleBucket(slot) !== ref.bucket || slot.getTime() > now.getTime()) {
-        return { job, status: 'skipped-idempotent' };
-    }
-    if (schedule.lastScheduledSlot && new Date(schedule.lastScheduledSlot).getTime() >= slot.getTime()) {
-        return { job, status: 'skipped-idempotent' };
-    }
-    if (job.state !== 'ACTIVE')
-        return { job, status: 'skipped-idempotent' };
     const active = job.tasks.some(task => ['QUEUED', 'RUNNING'].includes(task.state));
-    if (active && schedule.concurrencyPolicy === 'skip') {
-        schedule.lastScheduledSlot = slot.toISOString();
-        schedule.nextRunAt = nextScheduleRun(schedule, now).toISOString();
-        job.updatedAt = now.toISOString();
-        await new GitHubStore(client, repository, ref.prNumber, trustedAuthors).saveJob(job);
-        return { job, status: 'skipped-active' };
-    }
-    if (active && schedule.concurrencyPolicy === 'queue') {
+    const schedulerStore = storeFactory ? storeFactory() : new GitHubStore(client, repository, ref.prNumber, trustedAuthors);
+    let actionStatus = null;
+    const decision = await dispatchScheduledRun({
+        slotDue: scheduleBucket(slot) === ref.bucket && slot.getTime() <= now.getTime(),
+        slotUnclaimed: !schedule.lastScheduledSlot || new Date(schedule.lastScheduledSlot).getTime() < slot.getTime(),
+        jobActive: job.state === 'ACTIVE', hasActiveTasks: active,
+        concurrencySkip: schedule.concurrencyPolicy === 'skip', concurrencyQueue: schedule.concurrencyPolicy === 'queue',
+        runMissed: schedule.missedRunPolicy === 'run',
+    }, async (actionId) => {
+        if (actionId === 'schedule.skipActiveAdvance') {
+            schedule.lastScheduledSlot = slot.toISOString();
+            schedule.nextRunAt = nextScheduleRun(schedule, now).toISOString();
+            job.updatedAt = now.toISOString();
+            await schedulerStore.saveJob(job);
+            actionStatus = 'skipped-active';
+            return {};
+        }
+        if (actionId === 'schedule.claimFromSlot' || actionId === 'schedule.claimFromNow') {
+            schedule.lastScheduledSlot = slot.toISOString();
+            schedule.currentRunSlot = slot.toISOString();
+            schedule.nextRunAt = nextScheduleRun(schedule, actionId === 'schedule.claimFromSlot' ? slot : now).toISOString();
+            job.updatedAt = now.toISOString();
+            await schedulerStore.saveJob(job);
+            job = await schedulerStore.load(job.id);
+            return {};
+        }
+        throw new Error('Unsupported schedule graph action ' + actionId);
+    });
+    if (!decision.accepted || decision.target === 'skip_idempotent')
+        return { job, status: 'skipped-idempotent' };
+    if (actionStatus === 'skipped-active' || decision.target === 'skip_active')
         return { job, status: 'skipped-active' };
-    }
-    const missedRunPolicy = schedule.missedRunPolicy;
-    schedule.lastScheduledSlot = slot.toISOString();
-    schedule.currentRunSlot = slot.toISOString();
-    schedule.nextRunAt = nextScheduleRun(schedule, missedRunPolicy === 'run' ? slot : now).toISOString();
-    job.updatedAt = now.toISOString();
-    const schedulerStore = new GitHubStore(client, repository, ref.prNumber, trustedAuthors);
-    await schedulerStore.saveJob(job);
-    job = await schedulerStore.load(job.id);
+    if (decision.target !== 'claimed')
+        return { job, status: 'skipped-idempotent' };
     if (!engine)
         throw new Error('Scheduled jobs require the local relayd scheduler engine');
     await engine.reconcile(job.id);
     await engine.idle();
     const finished = await schedulerStore.load(job.id);
     if (!finished.schedule)
-        throw new Error(`Scheduled job ${job.id} lost its schedule metadata`);
+        throw new Error('Scheduled job ' + job.id + ' lost its schedule metadata');
     finished.schedule.lastRunAt = now.toISOString();
     finished.updatedAt = now.toISOString();
     await schedulerStore.saveJob(finished);

package/dist/scheduler.js

@@ -1,16 +1,16 @@
 import { implementationTasks } from './runtime-status.js';
-import { decideJobLifecycle, decideTaskLifecycle } from './workflow/lifecycle.js';
+import { dispatchJobLifecycle, dispatchTaskLifecycle, dispatchTaskLifecycleSync } from './workflow/lifecycle.js';
 import { reconcileTaskDependencies } from './workflow/task-reconcile.js';
 export { dependencyReady, detectCycles } from './workflow/task-reconcile.js';
-import { applyJobWorkflowDecision, applyTaskWorkflowDecision } from './workflow/runtime.js';
+import { dispatchScheduleCycle } from './workflow/schedule-cycle-v2.js';
 export function completionGateSatisfied(job) {
     if (job.schedule)
         return false;
     if (job.executionMode !== 'autonomous')
         return true;
-    const planners = job.tasks.filter(task => task.kind === 'planner');
-    return planners.some(task => task.state === 'SUCCEEDED' && task.plannerResult?.objective_status === 'satisfied')
-        && implementationTasks(job).every(task => task.state === 'SUCCEEDED');
+    const planSatisfied = (job.plans ?? []).some(plan => plan.status === 'SUCCEEDED' && plan.objectiveStatus === 'satisfied');
+    const legacySatisfied = (job.plans?.length ?? 0) === 0 && job.tasks.some(task => task.kind === 'planner' && task.state === 'SUCCEEDED' && task.plannerResult?.objective_status === 'satisfied');
+    return (planSatisfied || legacySatisfied) && implementationTasks(job).every(task => task.state === 'SUCCEEDED');
 }
 export function schedule(job) {
     reconcileTaskDependencies(job);
@@ -18,16 +18,21 @@ export function schedule(job) {
         ? job.tasks.filter(task => Date.parse(task.createdAt) >= Date.parse(job.schedule?.currentRunSlot ?? ''))
         : job.tasks;
     if (job.schedule) {
-        const planners = scopedTasks.filter(task => task.kind === 'planner');
-        const latest = planners.sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id)).at(-1);
-        if (latest?.state === 'SUCCEEDED' && latest.plannerResult?.objective_status === 'satisfied') {
+        const slot = Date.parse(job.schedule.currentRunSlot ?? '');
+        const scopedPlans = (job.plans ?? []).filter(plan => !Number.isFinite(slot) || Date.parse(plan.createdAt) >= slot).sort((a, b) => a.round - b.round || a.createdAt.localeCompare(b.createdAt));
+        const latestPlan = scopedPlans.at(-1);
+        const legacyLatest = scopedPlans.length === 0 ? scopedTasks.filter(task => task.kind === 'planner').sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id)).at(-1) : undefined;
+        dispatchScheduleCycle({
+            hasCurrentSlot: Boolean(job.schedule.currentRunSlot),
+            plannerSatisfied: latestPlan ? latestPlan.status === 'SUCCEEDED' && latestPlan.objectiveStatus === 'satisfied' : legacyLatest?.state === 'SUCCEEDED' && legacyLatest.plannerResult?.objective_status === 'satisfied',
+        }, () => {
             const slot = job.schedule.currentRunSlot ? Date.parse(job.schedule.currentRunSlot) : Number.NaN;
             const lastRun = job.schedule.lastRunAt ? Date.parse(job.schedule.lastRunAt) : Number.NaN;
             if (Number.isFinite(slot) && (!Number.isFinite(lastRun) || lastRun < slot))
                 job.schedule.lastRunAt = new Date().toISOString();
             job.schedule.currentRunSlot = null;
             job.updatedAt = new Date().toISOString();
-        }
+        });
     }
     return job;
 }
@@ -38,27 +43,23 @@ export function extendRetryBudget(task, windowSize = 3) {
     return Math.max(windowSize, (Math.floor(usedOrBudgeted / windowSize) + 1) * windowSize);
 }
 export function tryTransitionTaskEvent(task, event, context = {}) {
-    const decision = decideTaskLifecycle(task, event, context);
-    if (decision.accepted && decision.target)
-        applyTaskWorkflowDecision(task, decision);
-    return decision;
+    return dispatchTaskLifecycleSync(task, event, context);
 }
-export async function transitionTaskEvent(task, event, context = {}) {
+export async function transitionTaskEvent(task, event, context = {}, executeEffect, persist) {
     const from = task.state;
-    const decision = tryTransitionTaskEvent(task, event, context);
+    const decision = await dispatchTaskLifecycle(task, event, context, executeEffect, persist);
     if (!decision.accepted || !decision.target)
         throw new Error(decision.reason === 'ambiguous'
             ? `Ambiguous workflow transition from ${from} on ${event}`
             : `No enabled workflow transition from ${from} on ${event}`);
     return decision;
 }
-export async function transitionJobEvent(job, event, context = {}) {
-    const decision = decideJobLifecycle(job, event, context);
+export async function transitionJobEvent(job, event, context = {}, executeEffect, persist) {
+    const decision = await dispatchJobLifecycle(job, event, context, executeEffect, persist);
     if (!decision.accepted || !decision.target)
         throw new Error(decision.reason === 'ambiguous'
             ? `Ambiguous workflow transition from ${job.state} on ${event}`
             : `No enabled workflow transition from ${job.state} on ${event}`);
-    applyJobWorkflowDecision(job, decision);
     return decision;
 }
 export const SCHEDULE_RESOLUTION_MS = 600_000;

package/dist/store.js

@@ -126,7 +126,6 @@ export class InMemoryStore {
     }
 }
 export async function withGitHubRequestContext(client, context, work) { return client.withRequestContext ? client.withRequestContext(context, work) : work(); }
-export { createGitHubAppJwt, GhApiClient } from './github-client.js';
 async function githubGraphql(client, query, variables) {
     if (!client.graphql)
         throw new Error('GitHub GraphQL client is required');
@@ -257,6 +256,7 @@ export async function resolvePullRequest(client, repository, options) {
         throw error;
     }
 }
+export { GhApiClient, createGitHubAppJwt } from './github-client.js';
 export { GitHubStore } from './store-github.js';
 export async function listManagedGitHubJobs(client, repository, trustedAuthors) {
     if (!client.graphql)

package/dist/task-actions.js

@@ -0,0 +1,139 @@
+import { extendRetryBudget, transitionTaskEvent, tryTransitionTaskEvent } from './scheduler.js';
+import { selectRelatedTaskMutations } from './workflow/task-action-policy.js';
+export const TASK_RETRY_ACTION = 'task.retry';
+export const TASK_UNBLOCK_RETRY_ACTION = 'task.unblock.retry';
+export const TASK_CANCEL_ACTION = 'task.cancel';
+export const TASK_RELEASE_ACTION = 'task.release';
+export const TASK_HOLD_ACTION = 'task.hold';
+export const TASK_COMPLETE_ACTION = 'task.complete';
+export const TASK_QUEUE_ACTION = 'task.queue';
+function lifecycleRejection(task, action) {
+    return new Error(`Task ${task.id} is not ${action} (${task.state})`);
+}
+async function transitionTaskAction(task, event, action, facts = {}) {
+    try {
+        await transitionTaskEvent(task, event, facts);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('No enabled workflow transition')) {
+            throw lifecycleRejection(task, action);
+        }
+        throw error;
+    }
+}
+function clearExecution(task) {
+    task.error = null;
+    task.leaseOwner = null;
+    task.leaseExpiresAt = null;
+    task.executionId = null;
+}
+/** Shared task.retry mutation. The canonical lifecycle graph is the sole legality authority. */
+export async function applyTaskRetryAction(task, policy = {}) {
+    if (task.kind === 'planner')
+        throw new Error(`Legacy planner Task ${task.id} is read-only; retry the Plan instead`);
+    await transitionTaskAction(task, 'retry', 'restartable');
+    if (policy.extendBudget)
+        task.maxAttempts = extendRetryBudget(task);
+    clearExecution(task);
+    return task;
+}
+/** Fixed-job authoritative unblock continuation: legality is owned by the lifecycle graph. */
+export async function applyTaskUnblockRetryAction(task) {
+    await transitionTaskAction(task, 'retry', 'retryable after unblock');
+    task.maxAttempts = extendRetryBudget(task);
+    clearExecution(task);
+    delete task.blockedBy;
+    return task;
+}
+export function tryApplyTaskCancelAction(task, reason) {
+    if (task.kind === 'planner')
+        return false;
+    const decision = tryTransitionTaskEvent(task, 'cancel');
+    if (!decision.accepted)
+        return false;
+    task.error = reason;
+    task.leaseOwner = null;
+    task.leaseExpiresAt = null;
+    task.executionId = null;
+    return true;
+}
+export async function applyTaskCancelAction(task, reason) {
+    if (task.kind === 'planner')
+        throw new Error(`Legacy planner Task ${task.id} is read-only`);
+    if (!tryApplyTaskCancelAction(task, reason))
+        throw lifecycleRejection(task, 'cancellable');
+    return task;
+}
+export async function applyTaskReleaseAction(task) {
+    await transitionTaskAction(task, 'release', 'releasable');
+    return task;
+}
+export async function applyTaskHoldAction(task) {
+    await transitionTaskAction(task, 'hold', 'holdable');
+    return task;
+}
+export async function applyTaskQueueAction(job, task) {
+    const taskMap = new Map(job.tasks.map(item => [item.id, item]));
+    const dependenciesSatisfied = task.dependencies.every(id => taskMap.get(id)?.state === 'SUCCEEDED');
+    await transitionTaskAction(task, 'queue', 'queueable', { dependenciesSatisfied });
+    clearExecution(task);
+    return task;
+}
+export async function applyOrchestratorCompleteAction(task, summary) {
+    if (task.adapter !== 'orchestrator')
+        throw new Error('task complete is only valid for adapter=orchestrator self-tasks');
+    const originalState = task.state;
+    tryTransitionTaskEvent(task, 'task.started');
+    task.attempt = Math.max(task.attempt, 1);
+    task.result = { summary };
+    clearExecution(task);
+    try {
+        await transitionTaskEvent(task, 'task.completed');
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('No enabled workflow transition')) {
+            throw new Error(`Task ${task.id} is ${originalState}; only QUEUED or RUNNING orchestrator tasks can be completed`);
+        }
+        throw error;
+    }
+    return task;
+}
+async function applySelectedRelatedTaskMutations(job, mutations) {
+    const changed = [];
+    for (const mutation of mutations) {
+        const related = job.tasks.find(item => item.id === mutation.taskId);
+        if (!related)
+            throw new Error(`Related task ${mutation.taskId} not found`);
+        if (mutation.mutation === 'cancel')
+            await applyTaskCancelAction(related, mutation.reason);
+        changed.push(related);
+    }
+    return changed;
+}
+/** Compatibility bridge: domain mutation only; adapters own wake/reconcile/output behavior. */
+export async function dispatchTaskAction(store, request) {
+    const job = await store.load(request.jobId);
+    const task = job.tasks.find(item => item.id === request.taskId);
+    if (!task)
+        throw new Error(`Task ${request.taskId} not found`);
+    const relatedMutations = selectRelatedTaskMutations(job, task, request.id);
+    if (request.id === TASK_RETRY_ACTION)
+        await applyTaskRetryAction(task, { extendBudget: true });
+    else if (request.id === TASK_UNBLOCK_RETRY_ACTION)
+        await applyTaskUnblockRetryAction(task);
+    else if (request.id === TASK_CANCEL_ACTION)
+        await applyTaskCancelAction(task, 'Cancelled by user');
+    else if (request.id === TASK_RELEASE_ACTION)
+        await applyTaskReleaseAction(task);
+    else if (request.id === TASK_HOLD_ACTION)
+        await applyTaskHoldAction(task);
+    else if (request.id === TASK_QUEUE_ACTION)
+        await applyTaskQueueAction(job, task);
+    else
+        throw new Error(`Unsupported task action ${request.id}`);
+    const changedRelated = await applySelectedRelatedTaskMutations(job, relatedMutations);
+    await store.saveTask(task);
+    for (const related of changedRelated)
+        await store.saveTask(related);
+    return { job, task };
+}