@shepai/cli 1.150.0 → 1.150.1-pr441.b309db7

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/fast-implement.node.js

@@ -11,14 +11,12 @@
  */
 import { execSync } from 'node:child_process';
 import { isGraphBubbleUp } from '@langchain/langgraph';
-import { createNodeLogger, buildExecutorOptions, retryExecute, getCompletedPhases, markPhaseComplete, saveEvidenceManifest, } from './node-helpers.js';
+import { createNodeLogger, buildExecutorOptions, retryExecute, getCompletedPhases, markPhaseComplete, } from './node-helpers.js';
 import { reportNodeStart } from '../heartbeat.js';
 import { recordPhaseStart, recordPhaseEnd } from '../phase-timing-context.js';
 import { updateNodeLifecycle } from '../lifecycle-context.js';
 import { buildFastImplementPrompt } from './prompts/fast-implement.prompt.js';
-import { buildEvidencePrompt } from './prompts/evidence-prompts.js';
-import { parseEvidenceRecords } from './evidence-output-parser.js';
-import { hasSettings, getSettings } from '../../../settings.service.js';
+import { createEvidenceNode } from './evidence.node.js';
 /**
  * Factory that creates the fast-implement node function.
  *
@@ -62,11 +60,15 @@ export function createFastImplementNode(executor) {
             if (!hasWorktreeChanges(cwd) && !hasNewCommits(cwd)) {
                 throw new Error('[fast-implement] Agent produced no file changes — it may have entered plan mode or asked questions instead of implementing. Retrying.');
             }
-            // --- Evidence sub-agent: capture proof of completion (settings-gated) ---
-            const evidenceEnabled = hasSettings() && getSettings().workflow.enableEvidence;
-            const evidence = evidenceEnabled ? await collectEvidence(executor, state, log) : [];
-            if (!evidenceEnabled) {
-                log.info('Evidence collection disabled via settings — skipping');
+            // --- Evidence sub-agent: capture proof of completion (feature-gated) ---
+            let evidence = [];
+            if (state.enableEvidence) {
+                const evidenceNode = createEvidenceNode(executor);
+                const evidenceResult = await evidenceNode(state);
+                evidence = evidenceResult.evidence ?? [];
+            }
+            else {
+                log.info('Evidence collection disabled — skipping');
             }
             await recordPhaseEnd(timingId, durationMs, {
                 inputTokens: result.usage?.inputTokens,
@@ -106,39 +108,6 @@ export function createFastImplementNode(executor) {
         }
     };
 }
-/**
- * Sub-agent call to collect evidence after fast implementation completes.
- * Graceful degradation: returns empty array on any failure so evidence
- * collection never blocks the workflow.
- */
-async function collectEvidence(executor, state, log) {
-    try {
-        log.info('Collecting evidence (sub-agent)');
-        const commitEvidence = hasSettings() && getSettings().workflow.commitEvidence;
-        const prompt = buildEvidencePrompt(state, { commitEvidence });
-        const options = buildExecutorOptions(state);
-        const result = await retryExecute(executor, prompt, options, { logger: log });
-        try {
-            const evidence = parseEvidenceRecords(result.result);
-            log.info(`Parsed ${evidence.length} evidence record(s)`);
-            saveEvidenceManifest(state, evidence, log);
-            return evidence;
-        }
-        catch (parseErr) {
-            const msg = parseErr instanceof Error ? parseErr.message : String(parseErr);
-            log.error(`Warning: evidence parsing failed: ${msg} — continuing with empty evidence`);
-            return [];
-        }
-    }
-    catch (err) {
-        // Re-throw LangGraph control-flow exceptions
-        if (isGraphBubbleUp(err))
-            throw err;
-        const msg = err instanceof Error ? err.message : String(err);
-        log.error(`Evidence collection failed: ${msg} — continuing without evidence`);
-        return [];
-    }
-}
 /**
  * Check whether the worktree has any uncommitted changes (new, modified, or deleted files).
  * Uses `git status --porcelain` which outputs one line per changed file, or empty if clean.

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/implement.node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"implement.node.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/implement.node.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AACpG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAqErD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,cAAc,IAG5C,OAAO,iBAAiB,KAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAiQ7E"}
+{"version":3,"file":"implement.node.d.ts","sourceRoot":"","sources":["../../../../../../../../../packages/core/src/infrastructure/services/agents/feature-agent/nodes/implement.node.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AACpG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAoErD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,cAAc,IAG5C,OAAO,iBAAiB,KAAG,OAAO,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAiQ7E"}

package/dist/packages/core/src/infrastructure/services/agents/feature-agent/nodes/implement.node.js

@@ -16,7 +16,6 @@ import { recordPhaseStart, recordPhaseEnd, recordApprovalWaitStart, updatePhaseP
 import { updateNodeLifecycle } from '../lifecycle-context.js';
 import { buildImplementPhasePrompt, } from './prompts/implement.prompt.js';
 import { createEvidenceNode } from './evidence.node.js';
-import { hasSettings, getSettings } from '../../../settings.service.js';
 /**
  * Update feature.yaml with current implementation progress.
  * Silently no-ops if the file is missing or unparseable.
@@ -190,8 +189,8 @@ export function createImplementNode(executor) {
             log.info(`All phases complete — ${completedTasks}/${totalTasks} tasks (${elapsed}s)`);
             updateFeatureProgress(state.specDir, totalTasks, totalTasks, 'implementation-complete', null, log);
             messages.push(`[implement] Complete: ${totalTasks} tasks across ${totalPhases} phases (${elapsed}s)`);
-            // --- Evidence sub-agent: capture proof of completion (settings-gated) ---
-            const evidenceEnabled = hasSettings() && getSettings().workflow.enableEvidence;
+            // --- Evidence sub-agent: capture proof of completion (feature-gated) ---
+            const evidenceEnabled = state.enableEvidence;
             let evidenceResult = {};
             if (evidenceEnabled) {
                 const evidenceNode = createEvidenceNode(executor);

package/dist/packages/core/src/infrastructure/services/clock.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Real Clock Service
+ *
+ * Infrastructure implementation of IClock that returns the actual system time.
+ * Used in production; tests substitute a MockClock for deterministic behavior.
+ */
+import type { IClock } from '../../application/ports/output/services/clock.interface.js';
+export declare class RealClock implements IClock {
+    now(): Date;
+}
+//# sourceMappingURL=clock.d.ts.map

package/dist/packages/core/src/infrastructure/services/clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/src/infrastructure/services/clock.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4DAA4D,CAAC;AAEzF,qBACa,SAAU,YAAW,MAAM;IACtC,GAAG,IAAI,IAAI;CAGZ"}

package/dist/packages/core/src/infrastructure/services/clock.js

@@ -0,0 +1,22 @@
+/**
+ * Real Clock Service
+ *
+ * Infrastructure implementation of IClock that returns the actual system time.
+ * Used in production; tests substitute a MockClock for deterministic behavior.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from 'tsyringe';
+let RealClock = class RealClock {
+    now() {
+        return new Date();
+    }
+};
+RealClock = __decorate([
+    injectable()
+], RealClock);
+export { RealClock };

package/dist/packages/core/src/infrastructure/services/notifications/notification.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"notification.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/notifications/notification.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,iBAAiB,EAElB,MAAM,qCAAqC,CAAC;AAE7C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8EAA8E,CAAC;AAEzH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAgB7D,qBAAa,mBAAoB,YAAW,oBAAoB;IAC9D,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkB;IACtC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;gBAEtC,GAAG,EAAE,eAAe,EAAE,eAAe,EAAE,eAAe;IAKlE,MAAM,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI;CAiBvC"}
+{"version":3,"file":"notification.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/notifications/notification.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,iBAAiB,EAElB,MAAM,qCAAqC,CAAC;AAE7C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8EAA8E,CAAC;AAEzH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAmB7D,qBAAa,mBAAoB,YAAW,oBAAoB;IAC9D,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkB;IACtC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;gBAEtC,GAAG,EAAE,eAAe,EAAE,eAAe,EAAE,eAAe;IAKlE,MAAM,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI;CAiBvC"}

package/dist/packages/core/src/infrastructure/services/notifications/notification.service.js

@@ -22,6 +22,9 @@ const EVENT_TYPE_TO_CONFIG_KEY = {
     [NotificationEventType.PrChecksFailed]: 'prChecksFailed',
     [NotificationEventType.PrBlocked]: 'prBlocked',
     [NotificationEventType.MergeReviewReady]: 'mergeReviewReady',
+    [NotificationEventType.WorkflowStarted]: 'workflowStarted',
+    [NotificationEventType.WorkflowCompleted]: 'workflowCompleted',
+    [NotificationEventType.WorkflowFailed]: 'workflowFailed',
 };
 export class NotificationService {
     bus;

package/dist/packages/core/src/infrastructure/services/workflow-scheduler/workflow-scheduler.service.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Workflow Scheduler Service
+ *
+ * Polls for due scheduled workflows and executes them sequentially.
+ * Follows the NotificationWatcherService/PrSyncWatcherService pattern:
+ * - Singleton with start()/stop()/isRunning() lifecycle
+ * - setInterval-based polling
+ * - Immediate first poll on start()
+ * - Graceful shutdown via clearInterval
+ *
+ * Uses IClock for all time operations (deterministic testing).
+ * Uses croner only for validation and nextRun() calculation.
+ *
+ * Each tick:
+ * 1. Query enabled workflows where nextRunAt <= clock.now()
+ * 2. Enqueue due workflows into FIFO queue
+ * 3. If no execution is running, dequeue and execute next
+ * 4. Every 100 ticks: run retention cleanup
+ *
+ * Crash recovery on startup:
+ * - Mark stale 'running' executions as 'failed'
+ * - Recalculate nextRunAt for all enabled workflows
+ */
+import type { IWorkflowRepository } from '../../../application/ports/output/repositories/workflow-repository.interface.js';
+import type { IWorkflowExecutionRepository } from '../../../application/ports/output/repositories/workflow-execution-repository.interface.js';
+import type { IClock } from '../../../application/ports/output/services/clock.interface.js';
+import type { INotificationService } from '../../../application/ports/output/services/notification-service.interface.js';
+export declare class WorkflowSchedulerService {
+    private readonly workflowRepo;
+    private readonly executionRepo;
+    private readonly clock;
+    private readonly notificationService;
+    private readonly pollIntervalMs;
+    private readonly retentionDays;
+    private intervalId;
+    private tickCount;
+    private isExecuting;
+    private readonly queue;
+    constructor(workflowRepo: IWorkflowRepository, executionRepo: IWorkflowExecutionRepository, clock: IClock, notificationService: INotificationService, pollIntervalMs?: number, retentionDays?: number);
+    isRunning(): boolean;
+    start(): Promise<void>;
+    stop(): void;
+    private poll;
+    private executeWorkflow;
+    private recoverStaleExecutions;
+    private runRetentionCleanup;
+    private emitNotification;
+}
+/**
+ * Initialize the workflow scheduler singleton.
+ * Must be called once during daemon startup.
+ */
+export declare function initializeWorkflowScheduler(workflowRepo: IWorkflowRepository, executionRepo: IWorkflowExecutionRepository, clock: IClock, notificationService: INotificationService, pollIntervalMs?: number, retentionDays?: number): void;
+/**
+ * Get the workflow scheduler singleton.
+ */
+export declare function getWorkflowScheduler(): WorkflowSchedulerService;
+/**
+ * Check if the workflow scheduler has been initialized.
+ */
+export declare function hasWorkflowScheduler(): boolean;
+/**
+ * Reset the workflow scheduler singleton (for testing purposes only).
+ * Stops the scheduler if running before resetting.
+ *
+ * @internal
+ */
+export declare function resetWorkflowScheduler(): void;
+//# sourceMappingURL=workflow-scheduler.service.d.ts.map

package/dist/packages/core/src/infrastructure/services/workflow-scheduler/workflow-scheduler.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-scheduler.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/workflow-scheduler/workflow-scheduler.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAcH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iFAAiF,CAAC;AAC3H,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,2FAA2F,CAAC;AAC9I,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,+DAA+D,CAAC;AAC5F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8EAA8E,CAAC;AAOzH,qBAAa,wBAAwB;IACnC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAsB;IACnD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA+B;IAC7D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAuB;IAC3D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IAEvC,OAAO,CAAC,UAAU,CAA+C;IACjE,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;gBAGpC,YAAY,EAAE,mBAAmB,EACjC,aAAa,EAAE,4BAA4B,EAC3C,KAAK,EAAE,MAAM,EACb,mBAAmB,EAAE,oBAAoB,EACzC,cAAc,GAAE,MAAiC,EACjD,aAAa,GAAE,MAA+B;IAUhD,SAAS,IAAI,OAAO;IAId,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAc5B,IAAI,IAAI,IAAI;YAOE,IAAI;YA2CJ,eAAe;YA6Hf,sBAAsB;YAqBtB,mBAAmB;IAWjC,OAAO,CAAC,gBAAgB;CAkBzB;AAMD;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,mBAAmB,EACjC,aAAa,EAAE,4BAA4B,EAC3C,KAAK,EAAE,MAAM,EACb,mBAAmB,EAAE,oBAAoB,EACzC,cAAc,CAAC,EAAE,MAAM,EACvB,aAAa,CAAC,EAAE,MAAM,GACrB,IAAI,CAaN;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,wBAAwB,CAQ/D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAK7C"}

package/dist/packages/core/src/infrastructure/services/workflow-scheduler/workflow-scheduler.service.js

@@ -0,0 +1,270 @@
+/**
+ * Workflow Scheduler Service
+ *
+ * Polls for due scheduled workflows and executes them sequentially.
+ * Follows the NotificationWatcherService/PrSyncWatcherService pattern:
+ * - Singleton with start()/stop()/isRunning() lifecycle
+ * - setInterval-based polling
+ * - Immediate first poll on start()
+ * - Graceful shutdown via clearInterval
+ *
+ * Uses IClock for all time operations (deterministic testing).
+ * Uses croner only for validation and nextRun() calculation.
+ *
+ * Each tick:
+ * 1. Query enabled workflows where nextRunAt <= clock.now()
+ * 2. Enqueue due workflows into FIFO queue
+ * 3. If no execution is running, dequeue and execute next
+ * 4. Every 100 ticks: run retention cleanup
+ *
+ * Crash recovery on startup:
+ * - Mark stale 'running' executions as 'failed'
+ * - Recalculate nextRunAt for all enabled workflows
+ */
+import { randomUUID } from 'node:crypto';
+import { NotificationEventType, NotificationSeverity, WorkflowExecutionStatus, WorkflowTriggerType, } from '../../../domain/generated/output.js';
+import { calculateNextRunAt } from '../../../application/use-cases/workflows/cron-helpers.js';
+const DEFAULT_POLL_INTERVAL_MS = 60_000;
+const RETENTION_CLEANUP_INTERVAL_TICKS = 100;
+const DEFAULT_RETENTION_DAYS = 30;
+export class WorkflowSchedulerService {
+    workflowRepo;
+    executionRepo;
+    clock;
+    notificationService;
+    pollIntervalMs;
+    retentionDays;
+    intervalId = null;
+    tickCount = 0;
+    isExecuting = false;
+    queue = []; // workflow IDs
+    constructor(workflowRepo, executionRepo, clock, notificationService, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS, retentionDays = DEFAULT_RETENTION_DAYS) {
+        this.workflowRepo = workflowRepo;
+        this.executionRepo = executionRepo;
+        this.clock = clock;
+        this.notificationService = notificationService;
+        this.pollIntervalMs = pollIntervalMs;
+        this.retentionDays = retentionDays;
+    }
+    isRunning() {
+        return this.intervalId !== null;
+    }
+    async start() {
+        if (this.intervalId !== null)
+            return;
+        // Crash recovery: mark stale 'running' executions as 'failed'
+        await this.recoverStaleExecutions();
+        // Run first poll immediately
+        void this.poll();
+        this.intervalId = setInterval(() => {
+            void this.poll();
+        }, this.pollIntervalMs);
+    }
+    stop() {
+        if (this.intervalId !== null) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    async poll() {
+        try {
+            this.tickCount++;
+            // Find due workflows
+            const enabledWorkflows = await this.workflowRepo.findEnabled();
+            const now = this.clock.now();
+            for (const workflow of enabledWorkflows) {
+                if (workflow.nextRunAt &&
+                    new Date(workflow.nextRunAt).getTime() <= now.getTime() &&
+                    !this.queue.includes(workflow.id)) {
+                    this.queue.push(workflow.id);
+                }
+            }
+            // Also process any manually queued executions
+            const queuedExecutions = await this.executionRepo.findByStatus(WorkflowExecutionStatus.Queued);
+            for (const execution of queuedExecutions) {
+                if (!this.queue.includes(execution.workflowId)) {
+                    this.queue.push(execution.workflowId);
+                }
+            }
+            // Execute one queued workflow if nothing is running
+            if (!this.isExecuting && this.queue.length > 0) {
+                const workflowId = this.queue.shift();
+                void this.executeWorkflow(workflowId, queuedExecutions);
+            }
+            // Retention cleanup every N ticks
+            if (this.tickCount % RETENTION_CLEANUP_INTERVAL_TICKS === 0) {
+                await this.runRetentionCleanup();
+            }
+        }
+        catch {
+            // DB not ready or query failed — skip this poll cycle
+        }
+    }
+    async executeWorkflow(workflowId, existingQueuedExecutions) {
+        this.isExecuting = true;
+        try {
+            const workflow = await this.workflowRepo.findById(workflowId);
+            if (!workflow) {
+                this.isExecuting = false;
+                return;
+            }
+            // Find or create execution record
+            let execution = existingQueuedExecutions.find((e) => e.workflowId === workflowId && e.status === WorkflowExecutionStatus.Queued);
+            const now = this.clock.now();
+            if (!execution) {
+                // Create execution record for scheduled trigger
+                execution = {
+                    id: randomUUID(),
+                    workflowId,
+                    triggerType: WorkflowTriggerType.Scheduled,
+                    status: WorkflowExecutionStatus.Queued,
+                    startedAt: now,
+                    createdAt: now,
+                    updatedAt: now,
+                };
+                await this.executionRepo.create(execution);
+            }
+            // Transition to Running
+            execution = {
+                ...execution,
+                status: WorkflowExecutionStatus.Running,
+                startedAt: now,
+                updatedAt: now,
+            };
+            await this.executionRepo.update(execution);
+            // Emit WorkflowStarted event
+            this.emitNotification(NotificationEventType.WorkflowStarted, NotificationSeverity.Info, workflow, execution, `Workflow "${workflow.name}" started`);
+            try {
+                // Execute the workflow prompt
+                // For now, this is a placeholder — the actual agent execution
+                // will be wired in via the CLI/daemon integration (Phase 4).
+                // The scheduler creates the record and manages state transitions.
+                // Agent execution would happen here via IAgentRunner.
+                const completedAt = this.clock.now();
+                const durationMs = completedAt.getTime() - now.getTime();
+                // Mark as completed
+                execution = {
+                    ...execution,
+                    status: WorkflowExecutionStatus.Completed,
+                    completedAt,
+                    durationMs,
+                    updatedAt: completedAt,
+                };
+                await this.executionRepo.update(execution);
+                // Emit WorkflowCompleted event
+                this.emitNotification(NotificationEventType.WorkflowCompleted, NotificationSeverity.Success, workflow, execution, `Workflow "${workflow.name}" completed successfully`);
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                const failedAt = this.clock.now();
+                execution = {
+                    ...execution,
+                    status: WorkflowExecutionStatus.Failed,
+                    completedAt: failedAt,
+                    durationMs: failedAt.getTime() - now.getTime(),
+                    errorMessage,
+                    updatedAt: failedAt,
+                };
+                await this.executionRepo.update(execution);
+                // Emit WorkflowFailed event
+                this.emitNotification(NotificationEventType.WorkflowFailed, NotificationSeverity.Error, workflow, execution, `Workflow "${workflow.name}" failed: ${errorMessage}`);
+            }
+            // Update workflow lastRunAt and recalculate nextRunAt
+            const updateNow = this.clock.now();
+            const updatedWorkflow = {
+                ...workflow,
+                lastRunAt: updateNow,
+                updatedAt: updateNow,
+            };
+            if (workflow.cronExpression && workflow.enabled) {
+                const nextRunAt = calculateNextRunAt(workflow.cronExpression, workflow.timezone, updateNow);
+                updatedWorkflow.nextRunAt = nextRunAt ?? undefined;
+            }
+            else {
+                updatedWorkflow.nextRunAt = undefined;
+            }
+            await this.workflowRepo.update(updatedWorkflow);
+        }
+        finally {
+            this.isExecuting = false;
+        }
+    }
+    async recoverStaleExecutions() {
+        try {
+            const staleExecutions = await this.executionRepo.findByStatus(WorkflowExecutionStatus.Running);
+            const now = this.clock.now();
+            for (const execution of staleExecutions) {
+                await this.executionRepo.update({
+                    ...execution,
+                    status: WorkflowExecutionStatus.Failed,
+                    completedAt: now,
+                    errorMessage: 'Daemon crashed during execution',
+                    updatedAt: now,
+                });
+            }
+        }
+        catch {
+            // Best-effort recovery
+        }
+    }
+    async runRetentionCleanup() {
+        try {
+            const cutoff = new Date(this.clock.now().getTime() - this.retentionDays * 24 * 60 * 60 * 1000);
+            await this.executionRepo.deleteOlderThan(cutoff);
+        }
+        catch {
+            // Best-effort cleanup
+        }
+    }
+    emitNotification(eventType, severity, workflow, execution, message) {
+        const event = {
+            eventType,
+            agentRunId: execution.id,
+            featureId: workflow.id,
+            featureName: workflow.name,
+            message,
+            severity,
+            timestamp: this.clock.now().toISOString(),
+        };
+        this.notificationService.notify(event);
+    }
+}
+// --- Singleton accessors (follows NotificationWatcherService pattern) ---
+let schedulerInstance = null;
+/**
+ * Initialize the workflow scheduler singleton.
+ * Must be called once during daemon startup.
+ */
+export function initializeWorkflowScheduler(workflowRepo, executionRepo, clock, notificationService, pollIntervalMs, retentionDays) {
+    if (schedulerInstance !== null) {
+        throw new Error('Workflow scheduler already initialized. Cannot re-initialize.');
+    }
+    schedulerInstance = new WorkflowSchedulerService(workflowRepo, executionRepo, clock, notificationService, pollIntervalMs, retentionDays);
+}
+/**
+ * Get the workflow scheduler singleton.
+ */
+export function getWorkflowScheduler() {
+    if (schedulerInstance === null) {
+        throw new Error('Workflow scheduler not initialized. Call initializeWorkflowScheduler() during daemon startup.');
+    }
+    return schedulerInstance;
+}
+/**
+ * Check if the workflow scheduler has been initialized.
+ */
+export function hasWorkflowScheduler() {
+    return schedulerInstance !== null;
+}
+/**
+ * Reset the workflow scheduler singleton (for testing purposes only).
+ * Stops the scheduler if running before resetting.
+ *
+ * @internal
+ */
+export function resetWorkflowScheduler() {
+    if (schedulerInstance !== null) {
+        schedulerInstance.stop();
+    }
+    schedulerInstance = null;
+}

package/dist/src/presentation/cli/commands/_serve.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_serve.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/_serve.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,OAAO,EAAwB,MAAM,WAAW,CAAC;AAwB1D;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CA0D5C"}
+{"version":3,"file":"_serve.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/_serve.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,OAAO,EAAwB,MAAM,WAAW,CAAC;AAiC1D;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CA0E5C"}

package/dist/src/presentation/cli/commands/_serve.command.js

@@ -29,6 +29,8 @@ import { container } from '../../../../packages/core/src/infrastructure/di/conta
 import { setVersionEnvVars } from '../../../../packages/core/src/infrastructure/services/version.service.js';
 import { resolveWebDir } from '../../../../packages/core/src/infrastructure/services/web-server.service.js';
 import { initializeNotificationWatcher, getNotificationWatcher, } from '../../../../packages/core/src/infrastructure/services/notifications/notification-watcher.service.js';
+import { initializeWorkflowScheduler, getWorkflowScheduler, hasWorkflowScheduler, } from '../../../../packages/core/src/infrastructure/services/workflow-scheduler/workflow-scheduler.service.js';
+import { hasSettings, getSettings } from '../../../../packages/core/src/infrastructure/services/settings.service.js';
 function parsePort(value) {
     const port = parseInt(value, 10);
     if (isNaN(port) || port < 1024 || port > 65535) {
@@ -62,6 +64,15 @@ export function createServeCommand() {
             const notificationService = container.resolve('INotificationService');
             initializeNotificationWatcher(runRepo, phaseTimingRepo, featureRepo, notificationService);
             getNotificationWatcher().start();
+            // Start workflow scheduler (only when feature flag is enabled)
+            const scheduledWorkflowsEnabled = hasSettings() && getSettings().featureFlags?.scheduledWorkflows === true;
+            if (scheduledWorkflowsEnabled) {
+                const workflowRepo = container.resolve('IWorkflowRepository');
+                const executionRepo = container.resolve('IWorkflowExecutionRepository');
+                const clock = container.resolve('IClock');
+                initializeWorkflowScheduler(workflowRepo, executionRepo, clock, notificationService);
+                await getWorkflowScheduler().start();
+            }
             // Graceful shutdown handler — identical pattern to ui.command.ts
             let isShuttingDown = false;
             const shutdown = async () => {
@@ -71,6 +82,9 @@ export function createServeCommand() {
                 // Force exit after 5s if graceful shutdown stalls
                 const forceExit = setTimeout(() => process.exit(0), 5000);
                 forceExit.unref();
+                if (hasWorkflowScheduler()) {
+                    getWorkflowScheduler().stop();
+                }
                 getNotificationWatcher().stop();
                 const deploymentService = container.resolve('IDeploymentService');
                 deploymentService.stopAll();

package/dist/src/presentation/cli/commands/workflow/create.command.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Workflow Create Command
+ *
+ * Create a new scheduled workflow definition with a name, prompt, and optional
+ * description, tool constraints, and template.
+ *
+ * Usage:
+ *   shep workflow create <name> --prompt <prompt> [options]
+ *   shep workflow create <name> --template <template-name> [options]
+ */
+import { Command } from 'commander';
+export declare function createCreateCommand(): Command;
+//# sourceMappingURL=create.command.d.ts.map

package/dist/src/presentation/cli/commands/workflow/create.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/workflow/create.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAiBpC,wBAAgB,mBAAmB,IAAI,OAAO,CA+E7C"}

package/dist/src/presentation/cli/commands/workflow/create.command.js

@@ -0,0 +1,83 @@
+/**
+ * Workflow Create Command
+ *
+ * Create a new scheduled workflow definition with a name, prompt, and optional
+ * description, tool constraints, and template.
+ *
+ * Usage:
+ *   shep workflow create <name> --prompt <prompt> [options]
+ *   shep workflow create <name> --template <template-name> [options]
+ */
+import { Command } from 'commander';
+import { container } from '../../../../../packages/core/src/infrastructure/di/container.js';
+import { CreateWorkflowUseCase } from '../../../../../packages/core/src/application/use-cases/workflows/create-workflow.use-case.js';
+import { colors, messages } from '../../ui/index.js';
+import { getIssueTriageTemplate } from '../../../../../packages/core/src/application/use-cases/workflows/templates/issue-triage.template.js';
+import { getBranchRebaseTemplate } from '../../../../../packages/core/src/application/use-cases/workflows/templates/branch-rebase.template.js';
+function collectToolConstraints(value, previous) {
+    return [...previous, value];
+}
+const TEMPLATES = {
+    'issue-triage': getIssueTriageTemplate,
+    'branch-rebase': getBranchRebaseTemplate,
+};
+export function createCreateCommand() {
+    return new Command('create')
+        .description('Create a new workflow')
+        .argument('<name>', 'Unique workflow name')
+        .option('-p, --prompt <prompt>', 'Agent prompt (the instruction the AI agent will execute)')
+        .option('-d, --description <text>', 'Human-readable description')
+        .option('-t, --tool-constraint <tool>', 'Allowed tool (repeatable)', collectToolConstraints, [])
+        .option('--template <name>', 'Create from built-in template (issue-triage, branch-rebase)')
+        .option('-r, --repo <path>', 'Repository path (defaults to current directory)')
+        .option('--disabled', 'Create in disabled state')
+        .action(async (name, options) => {
+        try {
+            let prompt = options.prompt;
+            let description = options.description;
+            let toolConstraints = options.toolConstraint.length > 0 ? options.toolConstraint : undefined;
+            // Resolve template if specified
+            if (options.template) {
+                const templateFactory = TEMPLATES[options.template];
+                if (!templateFactory) {
+                    messages.error(`Unknown template: "${options.template}". Available templates: ${Object.keys(TEMPLATES).join(', ')}`);
+                    process.exitCode = 1;
+                    return;
+                }
+                const template = templateFactory();
+                prompt = prompt ?? template.prompt;
+                description = description ?? template.description;
+                toolConstraints = toolConstraints ?? template.toolConstraints;
+            }
+            if (!prompt) {
+                messages.error('A prompt is required. Use --prompt <prompt> or --template <name>.');
+                process.exitCode = 1;
+                return;
+            }
+            const repositoryPath = options.repo ?? process.cwd();
+            const useCase = container.resolve(CreateWorkflowUseCase);
+            const workflow = await useCase.execute({
+                name,
+                prompt,
+                repositoryPath,
+                ...(description != null && { description }),
+                ...(toolConstraints != null && { toolConstraints }),
+                ...(options.disabled && { enabled: false }),
+            });
+            messages.newline();
+            messages.success('Workflow created');
+            console.log(`  ${colors.muted('Name:')}    ${colors.accent(workflow.name)}`);
+            console.log(`  ${colors.muted('ID:')}      ${workflow.id.substring(0, 8)}`);
+            console.log(`  ${colors.muted('Enabled:')} ${workflow.enabled ? colors.success('yes') : colors.muted('no')}`);
+            if (workflow.description) {
+                console.log(`  ${colors.muted('Desc:')}    ${workflow.description}`);
+            }
+            messages.newline();
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to create workflow', err);
+            process.exitCode = 1;
+        }
+    });
+}