@shepai/cli 1.136.0-pr440.bb6800a → 1.136.0-pr441.5eaafd1

package/dist/packages/core/src/infrastructure/repositories/sqlite-workflow.repository.js

@@ -0,0 +1,117 @@
+/**
+ * SQLite Workflow Repository Implementation
+ *
+ * Implements IWorkflowRepository using SQLite database.
+ * Uses prepared statements to prevent SQL injection.
+ * Excludes soft-deleted workflows (deleted_at IS NOT NULL) from queries by default.
+ */
+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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { injectable } from 'tsyringe';
+import { toDatabase, fromDatabase, } from '../persistence/sqlite/mappers/workflow.mapper.js';
+/**
+ * SQLite implementation of IWorkflowRepository.
+ * Manages ScheduledWorkflow persistence with CRUD operations.
+ */
+let SQLiteWorkflowRepository = class SQLiteWorkflowRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async create(workflow) {
+        const row = toDatabase(workflow);
+        const stmt = this.db.prepare(`
+      INSERT INTO scheduled_workflows (
+        id, name, description, prompt, tool_constraints,
+        cron_expression, timezone, enabled,
+        last_run_at, next_run_at,
+        repository_path, deleted_at,
+        created_at, updated_at
+      ) VALUES (
+        @id, @name, @description, @prompt, @tool_constraints,
+        @cron_expression, @timezone, @enabled,
+        @last_run_at, @next_run_at,
+        @repository_path, @deleted_at,
+        @created_at, @updated_at
+      )
+    `);
+        stmt.run(row);
+    }
+    async findById(id) {
+        const stmt = this.db.prepare('SELECT * FROM scheduled_workflows WHERE id = ? AND deleted_at IS NULL');
+        const row = stmt.get(id);
+        if (!row) {
+            return null;
+        }
+        return fromDatabase(row);
+    }
+    async findByName(name, repositoryPath) {
+        const stmt = this.db.prepare("SELECT * FROM scheduled_workflows WHERE name = ? AND REPLACE(repository_path, '\\', '/') = ? AND deleted_at IS NULL");
+        const row = stmt.get(name, repositoryPath.replace(/\\/g, '/'));
+        if (!row) {
+            return null;
+        }
+        return fromDatabase(row);
+    }
+    async findEnabled() {
+        const stmt = this.db.prepare('SELECT * FROM scheduled_workflows WHERE enabled = 1 AND deleted_at IS NULL ORDER BY created_at ASC');
+        const rows = stmt.all();
+        return rows.map(fromDatabase);
+    }
+    async list(filters) {
+        const conditions = [];
+        const params = [];
+        if (!filters?.includeDeleted) {
+            conditions.push('deleted_at IS NULL');
+        }
+        if (filters?.repositoryPath) {
+            conditions.push("REPLACE(repository_path, '\\', '/') = ?");
+            params.push(filters.repositoryPath.replace(/\\/g, '/'));
+        }
+        if (filters?.enabled !== undefined) {
+            conditions.push('enabled = ?');
+            params.push(filters.enabled ? 1 : 0);
+        }
+        const where = conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '';
+        const stmt = this.db.prepare(`SELECT * FROM scheduled_workflows${where} ORDER BY created_at ASC`);
+        const rows = stmt.all(...params);
+        return rows.map(fromDatabase);
+    }
+    async update(workflow) {
+        const row = toDatabase(workflow);
+        const stmt = this.db.prepare(`
+      UPDATE scheduled_workflows SET
+        name = @name,
+        description = @description,
+        prompt = @prompt,
+        tool_constraints = @tool_constraints,
+        cron_expression = @cron_expression,
+        timezone = @timezone,
+        enabled = @enabled,
+        last_run_at = @last_run_at,
+        next_run_at = @next_run_at,
+        repository_path = @repository_path,
+        deleted_at = @deleted_at,
+        updated_at = @updated_at
+      WHERE id = @id
+    `);
+        stmt.run(row);
+    }
+    async softDelete(id) {
+        const now = Date.now();
+        const stmt = this.db.prepare('UPDATE scheduled_workflows SET deleted_at = ?, updated_at = ? WHERE id = ?');
+        stmt.run(now, now, id);
+    }
+};
+SQLiteWorkflowRepository = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Object])
+], SQLiteWorkflowRepository);
+export { SQLiteWorkflowRepository };

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/feat/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAepC;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAgB3C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAc3C"}

package/dist/src/presentation/cli/commands/feat/index.js

@@ -21,8 +21,6 @@ import { createApproveCommand } from './approve.command.js';
 import { createRejectCommand } from './reject.command.js';
 import { createLogsCommand } from './logs.command.js';
 import { createAdoptCommand } from './adopt.command.js';
-import { createArchiveCommand } from './archive.command.js';
-import { createUnarchiveCommand } from './unarchive.command.js';
 /**
  * Create the feat command group
  */
@@ -39,7 +37,5 @@ export function createFeatCommand() {
         .addCommand(createApproveCommand())
         .addCommand(createRejectCommand())
         .addCommand(createLogsCommand())
-        .addCommand(createAdoptCommand())
-        .addCommand(createArchiveCommand())
-        .addCommand(createUnarchiveCommand());
+        .addCommand(createAdoptCommand());
 }

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

@@ -1 +1 @@
-{"version":3,"file":"ls.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/ls.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkLpC,wBAAgB,eAAe,IAAI,OAAO,CAwGzC"}
+{"version":3,"file":"ls.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/ls.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA6KpC,wBAAgB,eAAe,IAAI,OAAO,CAsGzC"}

package/dist/src/presentation/cli/commands/feat/ls.command.js

@@ -48,9 +48,6 @@ const STATUS_PRIORITY = {
  */
 function formatStatus(feature, run) {
     // Blocked features show "Waiting" — the parent relationship is conveyed by tree indentation
-    if (feature.lifecycle === 'Archived') {
-        return `${colors.muted(symbols.dotEmpty)} ${colors.muted('Archived')}`;
-    }
     if (feature.lifecycle === 'Deleting') {
         return `${colors.muted(symbols.spinner[0])} ${colors.muted('Deleting')}`;
     }
@@ -171,7 +168,6 @@ export function createLsCommand() {
         .description('List features')
         .option('-r, --repo <path>', 'Filter by repository path')
         .option('--include-deleted', 'Include soft-deleted features')
-        .option('--show-archived', 'Include archived features')
         .action(async (options) => {
         try {
             const useCase = container.resolve(ListFeaturesUseCase);
@@ -180,7 +176,6 @@ export function createLsCommand() {
             const filters = {
                 ...(options.repo && { repositoryPath: options.repo }),
                 ...(options.includeDeleted && { includeDeleted: true }),
-                ...(options.showArchived && { includeArchived: true }),
             };
             const features = await useCase.execute(Object.keys(filters).length > 0 ? filters : undefined);
             // Load agent runs and phase timings for all features in parallel

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"}