@shepai/cli 1.136.0-pr439.2a7af41 → 1.136.0-pr441.5eaafd1

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;
+        }
+    });
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Workflow Delete Command
+ *
+ * Delete a workflow (soft-delete). Execution history is preserved
+ * subject to the retention policy.
+ *
+ * Usage:
+ *   shep workflow delete <name>
+ *   shep workflow delete <name> --force
+ */
+import { Command } from 'commander';
+export declare function createDeleteCommand(): Command;
+//# sourceMappingURL=delete.command.d.ts.map

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

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

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

@@ -0,0 +1,50 @@
+/**
+ * Workflow Delete Command
+ *
+ * Delete a workflow (soft-delete). Execution history is preserved
+ * subject to the retention policy.
+ *
+ * Usage:
+ *   shep workflow delete <name>
+ *   shep workflow delete <name> --force
+ */
+import { Command } from 'commander';
+import { container } from '../../../../../packages/core/src/infrastructure/di/container.js';
+import { DeleteWorkflowUseCase } from '../../../../../packages/core/src/application/use-cases/workflows/delete-workflow.use-case.js';
+import { colors, messages } from '../../ui/index.js';
+export function createDeleteCommand() {
+    return new Command('delete')
+        .description('Delete a workflow')
+        .argument('<name>', 'Workflow name or ID')
+        .option('--force', 'Skip confirmation')
+        .option('-r, --repo <path>', 'Repository path (defaults to current directory)')
+        .action(async (nameOrId, options) => {
+        try {
+            // Confirmation prompt (skip with --force or non-interactive)
+            if (!options.force && process.stdin.isTTY) {
+                const readline = await import('node:readline');
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                const answer = await new Promise((resolve) => {
+                    rl.question(`  Delete workflow "${nameOrId}"? This will cancel queued executions. [y/N] `, resolve);
+                });
+                rl.close();
+                if (answer.toLowerCase() !== 'y') {
+                    messages.info('Cancelled');
+                    return;
+                }
+            }
+            const repositoryPath = options.repo ?? process.cwd();
+            const useCase = container.resolve(DeleteWorkflowUseCase);
+            const workflow = await useCase.execute(nameOrId, repositoryPath);
+            messages.success(`Deleted workflow "${colors.accent(workflow.name)}"`);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to delete workflow', err);
+            process.exitCode = 1;
+        }
+    });
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Workflow Disable Command
+ *
+ * Disable a workflow's schedule (manual triggers still allowed).
+ *
+ * Usage:
+ *   shep workflow disable <name>
+ */
+import { Command } from 'commander';
+export declare function createDisableCommand(): Command;
+//# sourceMappingURL=disable.command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"disable.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/workflow/disable.command.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,wBAAgB,oBAAoB,IAAI,OAAO,CAmB9C"}

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

@@ -0,0 +1,32 @@
+/**
+ * Workflow Disable Command
+ *
+ * Disable a workflow's schedule (manual triggers still allowed).
+ *
+ * Usage:
+ *   shep workflow disable <name>
+ */
+import { Command } from 'commander';
+import { container } from '../../../../../packages/core/src/infrastructure/di/container.js';
+import { ToggleWorkflowUseCase } from '../../../../../packages/core/src/application/use-cases/workflows/toggle-workflow.use-case.js';
+import { messages } from '../../ui/index.js';
+export function createDisableCommand() {
+    return new Command('disable')
+        .description('Disable a workflow schedule')
+        .argument('<name>', 'Workflow name or ID')
+        .option('-r, --repo <path>', 'Repository path (defaults to current directory)')
+        .action(async (nameOrId, options) => {
+        try {
+            const repositoryPath = options.repo ?? process.cwd();
+            const useCase = container.resolve(ToggleWorkflowUseCase);
+            const workflow = await useCase.execute(nameOrId, false, repositoryPath);
+            messages.success(`Workflow "${workflow.name}" disabled`);
+            messages.info('Manual triggers are still allowed via: shep workflow run <name>');
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to disable workflow', err);
+            process.exitCode = 1;
+        }
+    });
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Workflow Enable Command
+ *
+ * Enable a workflow's schedule.
+ *
+ * Usage:
+ *   shep workflow enable <name>
+ */
+import { Command } from 'commander';
+export declare function createEnableCommand(): Command;
+//# sourceMappingURL=enable.command.d.ts.map

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

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

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

@@ -0,0 +1,35 @@
+/**
+ * Workflow Enable Command
+ *
+ * Enable a workflow's schedule.
+ *
+ * Usage:
+ *   shep workflow enable <name>
+ */
+import { Command } from 'commander';
+import { container } from '../../../../../packages/core/src/infrastructure/di/container.js';
+import { ToggleWorkflowUseCase } from '../../../../../packages/core/src/application/use-cases/workflows/toggle-workflow.use-case.js';
+import { colors, messages } from '../../ui/index.js';
+import { formatTimestamp } from './format-helpers.js';
+export function createEnableCommand() {
+    return new Command('enable')
+        .description('Enable a workflow schedule')
+        .argument('<name>', 'Workflow name or ID')
+        .option('-r, --repo <path>', 'Repository path (defaults to current directory)')
+        .action(async (nameOrId, options) => {
+        try {
+            const repositoryPath = options.repo ?? process.cwd();
+            const useCase = container.resolve(ToggleWorkflowUseCase);
+            const workflow = await useCase.execute(nameOrId, true, repositoryPath);
+            messages.success(`Workflow "${workflow.name}" enabled`);
+            if (workflow.nextRunAt) {
+                console.log(`  ${colors.muted('Next run:')} ${formatTimestamp(new Date(workflow.nextRunAt))}`);
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to enable workflow', err);
+            process.exitCode = 1;
+        }
+    });
+}