@shepai/cli 1.179.1 → 1.180.0-pr548.764147

package/dist/packages/core/src/application/use-cases/interactive/send-interactive-message.use-case.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"send-interactive-message.use-case.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/use-cases/interactive/send-interactive-message.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sEAAsE,CAAC;AACvH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAE9E;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,qBACa,6BAA6B;IAGtC,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,0BAA0B;IAGhD,OAAO,CAAC,KAAK,EAAE,2BAA2B,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAS/E"}
+{"version":3,"file":"send-interactive-message.use-case.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/use-cases/interactive/send-interactive-message.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sEAAsE,CAAC;AACvH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAE9E;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;;GAMG;AACH,qBACa,6BAA6B;IAGtC,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,0BAA0B;IAGhD,OAAO,CAAC,KAAK,EAAE,2BAA2B,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAW/E"}

package/dist/packages/core/src/application/use-cases/interactive/send-interactive-message.use-case.js

@@ -32,7 +32,7 @@ let SendInteractiveMessageUseCase = class SendInteractiveMessageUseCase {
         this.service = service;
     }
     async execute(input) {
-        return this.service.sendUserMessage(input.featureId, input.content, input.worktreePath, input.model, input.agentType);
+        return this.service.sendUserMessage(input.featureId, input.content, input.worktreePath, input.model, input.agentType, input.systemPrompt, input.agentKickoffOverride);
     }
 };
 SendInteractiveMessageUseCase = __decorate([

package/dist/packages/core/src/application/use-cases/terminal/create-terminal-session.use-case.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Create Terminal Session Use Case
+ *
+ * Opens a new interactive PTY session rooted at an application's working
+ * directory (or any caller-supplied cwd). Returns an opaque session id
+ * that presentation layers use for subsequent input/output/resize calls.
+ */
+import type { CreatedTerminalSession, ITerminalSessionService } from '../../ports/output/services/terminal-session-service.interface.js';
+export interface CreateTerminalSessionCommand {
+    cwd: string;
+    cols?: number;
+    rows?: number;
+}
+export declare class CreateTerminalSessionUseCase {
+    private readonly terminals;
+    constructor(terminals: ITerminalSessionService);
+    execute(command: CreateTerminalSessionCommand): CreatedTerminalSession;
+}
+//# sourceMappingURL=create-terminal-session.use-case.d.ts.map

package/dist/packages/core/src/application/use-cases/terminal/create-terminal-session.use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-terminal-session.use-case.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/use-cases/terminal/create-terminal-session.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EACV,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,mEAAmE,CAAC;AAE3E,MAAM,WAAW,4BAA4B;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,qBACa,4BAA4B;IAGrC,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,uBAAuB;IAGrD,OAAO,CAAC,OAAO,EAAE,4BAA4B,GAAG,sBAAsB;CAUvE"}

package/dist/packages/core/src/application/use-cases/terminal/create-terminal-session.use-case.js

@@ -0,0 +1,42 @@
+/**
+ * Create Terminal Session Use Case
+ *
+ * Opens a new interactive PTY session rooted at an application's working
+ * directory (or any caller-supplied cwd). Returns an opaque session id
+ * that presentation layers use for subsequent input/output/resize calls.
+ */
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
+let CreateTerminalSessionUseCase = class CreateTerminalSessionUseCase {
+    terminals;
+    constructor(terminals) {
+        this.terminals = terminals;
+    }
+    execute(command) {
+        if (!command.cwd || command.cwd.trim().length === 0) {
+            throw new Error('cwd is required to create a terminal session');
+        }
+        return this.terminals.create({
+            cwd: command.cwd,
+            cols: command.cols,
+            rows: command.rows,
+        });
+    }
+};
+CreateTerminalSessionUseCase = __decorate([
+    injectable(),
+    __param(0, inject('ITerminalSessionService')),
+    __metadata("design:paramtypes", [Object])
+], CreateTerminalSessionUseCase);
+export { CreateTerminalSessionUseCase };

package/dist/packages/core/src/application/use-cases/workflows/run-workflow.use-case.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Run Workflow Use Case
+ *
+ * Orchestrates a multi-step workflow against an interactive session.
+ * Owns the step lifecycle — ensures rows exist, transitions each
+ * from pending → running → done/failed, and tags every message the
+ * agent produces during a step with the step's id — so the UI can
+ * render a robust tracker that survives refreshes and daemon
+ * restarts without any marker parsing.
+ *
+ * Contract with the session service:
+ *   - `setActiveStep(featureId, stepId)` BEFORE the agent turn →
+ *      every `persistMessage` call during the turn tags with stepId.
+ *   - `subscribeByFeature` + `waitForTurnDone` lets us sequentially
+ *      walk steps: each step awaits its own agent turn completion
+ *      before moving on.
+ *   - `clearActiveStep(featureId)` AFTER the turn — keeps later
+ *      out-of-band messages (e.g. a user message typed into the
+ *      chat after the workflow finishes) from being tagged.
+ *
+ * Robustness properties:
+ *   1. The step row transitions to `running` BEFORE `sendUserMessage`
+ *      and to `done`/`failed` AFTER `waitForTurnDone`, so any crash
+ *      between them leaves the row `running` — which boot-time
+ *      recovery flips to `interrupted`.
+ *   2. `ensureSteps` is idempotent; resuming just skips already-done
+ *      steps and fails fast on any `running`/`interrupted`/`failed`
+ *      row (user retry flow can reset them to `pending`).
+ */
+import type { IWorkflowStepRepository } from '../../ports/output/repositories/workflow-step-repository.interface.js';
+import type { IInteractiveSessionService } from '../../ports/output/services/interactive-session-service.interface.js';
+import type { SendInteractiveMessageUseCase } from '../interactive/send-interactive-message.use-case.js';
+import type { WorkflowDefinition } from '../../workflows/application-creation.workflow.js';
+export interface RunWorkflowInput {
+    featureId: string;
+    worktreePath: string;
+    workflow: WorkflowDefinition;
+    /**
+     * Optional wrapper applied to the FIRST step's prompt. The
+     * application-creation flow uses this to inject the
+     * "Read `SHEP_BRIEF.md` first" directive on turn 1 without
+     * polluting any of the later step prompts.
+     */
+    firstStepPromptWrapper?: (stepPrompt: string) => string;
+    /**
+     * Visible first chat bubble — what the user sees as their own
+     * first message. When set, the orchestrator uses this as the
+     * `content` of the first `sendMessage.execute` call (the agent
+     * sees a different prompt via `agentKickoffOverride` /
+     * `firstStepPromptWrapper`). Used by the application-creation
+     * flow to show "build me a todo app" instead of the full step 1
+     * instructions in the user bubble.
+     */
+    visibleFirstMessage?: string;
+    /**
+     * Optional model / agent overrides to thread through to the
+     * session service. Used by Application chat which pins its own
+     * model/agent on the Application entity.
+     */
+    model?: string;
+    agentType?: string;
+}
+export declare class RunWorkflowUseCase {
+    private readonly stepRepo;
+    private readonly session;
+    private readonly sendMessage;
+    constructor(stepRepo: IWorkflowStepRepository, session: IInteractiveSessionService, sendMessage: SendInteractiveMessageUseCase);
+    execute(input: RunWorkflowInput): Promise<void>;
+    /**
+     * Poll `getChatState` for a short window to resolve the session
+     * id of the session we just booted. This is a hot path that
+     * runs once per workflow — tens to low hundreds of ms typically.
+     */
+    private resolveSessionId;
+    private refreshStep;
+}
+//# sourceMappingURL=run-workflow.use-case.d.ts.map

package/dist/packages/core/src/application/use-cases/workflows/run-workflow.use-case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-workflow.use-case.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/use-cases/workflows/run-workflow.use-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uEAAuE,CAAC;AACrH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sEAAsE,CAAC;AACvH,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,qDAAqD,CAAC;AAEzG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kDAAkD,CAAC;AAE3F,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,kBAAkB,CAAC;IAC7B;;;;;OAKG;IACH,sBAAsB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC;IACxD;;;;;;;;OAQG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBACa,kBAAkB;IAG3B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAEzB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAExB,OAAO,CAAC,QAAQ,CAAC,WAAW;gBAJX,QAAQ,EAAE,uBAAuB,EAEjC,OAAO,EAAE,0BAA0B,EAEnC,WAAW,EAAE,6BAA6B;IAGvD,OAAO,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IA0HrD;;;;OAIG;YACW,gBAAgB;YAUhB,WAAW;CAK1B"}

package/dist/packages/core/src/application/use-cases/workflows/run-workflow.use-case.js

@@ -0,0 +1,191 @@
+/**
+ * Run Workflow Use Case
+ *
+ * Orchestrates a multi-step workflow against an interactive session.
+ * Owns the step lifecycle — ensures rows exist, transitions each
+ * from pending → running → done/failed, and tags every message the
+ * agent produces during a step with the step's id — so the UI can
+ * render a robust tracker that survives refreshes and daemon
+ * restarts without any marker parsing.
+ *
+ * Contract with the session service:
+ *   - `setActiveStep(featureId, stepId)` BEFORE the agent turn →
+ *      every `persistMessage` call during the turn tags with stepId.
+ *   - `subscribeByFeature` + `waitForTurnDone` lets us sequentially
+ *      walk steps: each step awaits its own agent turn completion
+ *      before moving on.
+ *   - `clearActiveStep(featureId)` AFTER the turn — keeps later
+ *      out-of-band messages (e.g. a user message typed into the
+ *      chat after the workflow finishes) from being tagged.
+ *
+ * Robustness properties:
+ *   1. The step row transitions to `running` BEFORE `sendUserMessage`
+ *      and to `done`/`failed` AFTER `waitForTurnDone`, so any crash
+ *      between them leaves the row `running` — which boot-time
+ *      recovery flips to `interrupted`.
+ *   2. `ensureSteps` is idempotent; resuming just skips already-done
+ *      steps and fails fast on any `running`/`interrupted`/`failed`
+ *      row (user retry flow can reset them to `pending`).
+ */
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'tsyringe';
+import { WorkflowStepStatus } from '../../../domain/generated/output.js';
+let RunWorkflowUseCase = class RunWorkflowUseCase {
+    stepRepo;
+    session;
+    sendMessage;
+    constructor(stepRepo, session, sendMessage) {
+        this.stepRepo = stepRepo;
+        this.session = session;
+        this.sendMessage = sendMessage;
+    }
+    async execute(input) {
+        // 1. Boot the session by sending the first step's prompt. The
+        //    very first `sendMessage.execute` causes the session
+        //    service to create the interactive session row in SQLite
+        //    and start the agent process asynchronously. We need a
+        //    stable `sessionId` for the workflow_steps FK, so we issue
+        //    the first send, then look up the freshly-created session
+        //    id via `getChatState`.
+        //
+        //    Note: the FIRST step's content is `visibleFirstMessage`
+        //    (the user's verbatim description), not the step prompt,
+        //    so the chat UI shows the user's own words in the first
+        //    bubble. The agent sees `firstStepPromptWrapper(step.prompt)`
+        //    via `agentKickoffOverride`.
+        const firstStepDef = input.workflow.steps[0];
+        if (!firstStepDef)
+            return;
+        // Subscribe before sending to avoid racing a fast first turn.
+        const firstTurnDone = this.session.waitForTurnDone(input.featureId);
+        const firstAgentPrompt = input.firstStepPromptWrapper
+            ? input.firstStepPromptWrapper(firstStepDef.prompt)
+            : firstStepDef.prompt;
+        await this.sendMessage.execute({
+            featureId: input.featureId,
+            content: input.visibleFirstMessage ?? firstStepDef.prompt,
+            worktreePath: input.worktreePath,
+            model: input.model,
+            agentType: input.agentType,
+            agentKickoffOverride: firstAgentPrompt,
+        });
+        // Resolve the session id — newly booted, so poll briefly.
+        const sessionId = await this.resolveSessionId(input.featureId);
+        if (!sessionId) {
+            // eslint-disable-next-line no-console
+            console.warn(`[run-workflow] no session id for ${input.featureId}`);
+            return;
+        }
+        // 2. Idempotent step bootstrap. The user-facing tracker now
+        //    has all 9 pending cards to render.
+        const seeds = input.workflow.steps.map((s, index) => ({
+            stepKey: s.stepKey,
+            stepIndex: index,
+            title: s.title,
+            description: s.description,
+        }));
+        const steps = await this.stepRepo.ensureSteps(sessionId, input.workflow.id, input.featureId, seeds);
+        for (const step of steps) {
+            this.session.notifyWorkflowStep(input.featureId, step);
+        }
+        // 3. Mark step 1 running, tag the in-flight first turn's
+        //    messages with its id, then wait for turn completion.
+        const firstStep = steps[0];
+        await this.stepRepo.updateStatus(firstStep.id, WorkflowStepStatus.running);
+        this.session.notifyWorkflowStep(input.featureId, await this.refreshStep(firstStep.id));
+        this.session.setActiveStep(input.featureId, firstStep.id);
+        try {
+            await firstTurnDone;
+            await this.stepRepo.updateStatus(firstStep.id, WorkflowStepStatus.done, {
+                summary: firstStepDef.title,
+            });
+            this.session.notifyWorkflowStep(input.featureId, await this.refreshStep(firstStep.id));
+        }
+        catch (err) {
+            await this.stepRepo.updateStatus(firstStep.id, WorkflowStepStatus.failed, {
+                error: err instanceof Error ? err.message : String(err),
+            });
+            this.session.notifyWorkflowStep(input.featureId, await this.refreshStep(firstStep.id));
+            this.session.clearActiveStep(input.featureId);
+            return;
+        }
+        this.session.clearActiveStep(input.featureId);
+        // 4. Walk remaining steps sequentially.
+        for (let i = 1; i < steps.length; i++) {
+            const step = steps[i];
+            const definition = input.workflow.steps[i];
+            if (step.status === WorkflowStepStatus.done)
+                continue;
+            if (step.status !== WorkflowStepStatus.pending)
+                return;
+            await this.stepRepo.updateStatus(step.id, WorkflowStepStatus.running);
+            this.session.notifyWorkflowStep(input.featureId, await this.refreshStep(step.id));
+            this.session.setActiveStep(input.featureId, step.id);
+            const turnDone = this.session.waitForTurnDone(input.featureId);
+            try {
+                await this.sendMessage.execute({
+                    featureId: input.featureId,
+                    content: definition.prompt,
+                    worktreePath: input.worktreePath,
+                    model: input.model,
+                    agentType: input.agentType,
+                });
+                await turnDone;
+                await this.stepRepo.updateStatus(step.id, WorkflowStepStatus.done, {
+                    summary: definition.title,
+                });
+                this.session.notifyWorkflowStep(input.featureId, await this.refreshStep(step.id));
+            }
+            catch (err) {
+                await this.stepRepo.updateStatus(step.id, WorkflowStepStatus.failed, {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                this.session.notifyWorkflowStep(input.featureId, await this.refreshStep(step.id));
+                return;
+            }
+            finally {
+                this.session.clearActiveStep(input.featureId);
+            }
+        }
+    }
+    /**
+     * Poll `getChatState` for a short window to resolve the session
+     * id of the session we just booted. This is a hot path that
+     * runs once per workflow — tens to low hundreds of ms typically.
+     */
+    async resolveSessionId(featureId) {
+        for (let attempt = 0; attempt < 50; attempt++) {
+            const chat = await this.session.getChatState(featureId);
+            const id = chat.sessionInfo?.sessionId ?? null;
+            if (id)
+                return id;
+            await new Promise((r) => setTimeout(r, 50));
+        }
+        return null;
+    }
+    async refreshStep(stepId) {
+        const row = await this.stepRepo.findById(stepId);
+        if (!row)
+            throw new Error(`Workflow step ${stepId} vanished`);
+        return row;
+    }
+};
+RunWorkflowUseCase = __decorate([
+    injectable(),
+    __param(0, inject('IWorkflowStepRepository')),
+    __param(1, inject('IInteractiveSessionService')),
+    __param(2, inject('SendInteractiveMessageUseCase')),
+    __metadata("design:paramtypes", [Object, Object, Function])
+], RunWorkflowUseCase);
+export { RunWorkflowUseCase };

package/dist/packages/core/src/application/workflows/application-creation.workflow.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Application-creation workflow definition.
+ *
+ * The eight steps Shep walks every new application through, with the
+ * friendly non-technical title/description the user sees in the
+ * tracker card AND the focused agent-facing prompt the orchestrator
+ * sends for that step.
+ *
+ * History note: an earlier version had separate `plan` and `content`
+ * steps. They produced agent text confirmations with no actual tool
+ * work, leaving lonely "title-only" cards in the tracker. Both have
+ * been folded into the `components` step which now plans, builds,
+ * and writes real content in a single agent turn.
+ *
+ * Key design notes:
+ *   - The orchestrator (`RunWorkflowUseCase`) sends each step's
+ *     `prompt` as a user turn against the SAME interactive session,
+ *     so the agent has full history from the previous steps.
+ *   - The very first step's prompt is decorated with a brief-read
+ *     directive by `CreateApplicationUseCase` so the agent reads
+ *     `SHEP_BRIEF.md` before doing anything else. Subsequent steps
+ *     can just say "do X" because the brief is already loaded.
+ *   - Titles and descriptions are user-facing. Never put code, paths,
+ *     or jargon in them — they show in step cards next to avatars.
+ */
+export interface WorkflowStepDefinition {
+    /** Stable key persisted in `workflow_steps.step_key`. */
+    stepKey: string;
+    /** User-facing card title. */
+    title: string;
+    /** User-facing card subtitle. */
+    description: string;
+    /** Focused agent prompt for this step. Sent as a user turn. */
+    prompt: string;
+}
+export interface WorkflowDefinition {
+    /** Versioned logical id persisted in `workflow_steps.workflow_id`. */
+    id: string;
+    /** Ordered step list. */
+    steps: WorkflowStepDefinition[];
+}
+export declare const APPLICATION_CREATION_WORKFLOW_ID = "application-creation-v2";
+/**
+ * The canonical application-creation workflow. Bumping the `id`
+ * suffix ("-v1" → "-v2") triggers a new set of step rows for any
+ * session that starts after the bump, without touching existing
+ * data. Old rows remain queryable by their old workflow id.
+ */
+export declare const APPLICATION_CREATION_WORKFLOW: WorkflowDefinition;
+//# sourceMappingURL=application-creation.workflow.d.ts.map

package/dist/packages/core/src/application/workflows/application-creation.workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-creation.workflow.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/src/application/workflows/application-creation.workflow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,MAAM,WAAW,sBAAsB;IACrC,yDAAyD;IACzD,OAAO,EAAE,MAAM,CAAC;IAChB,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,+DAA+D;IAC/D,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,sEAAsE;IACtE,EAAE,EAAE,MAAM,CAAC;IACX,yBAAyB;IACzB,KAAK,EAAE,sBAAsB,EAAE,CAAC;CACjC;AAED,eAAO,MAAM,gCAAgC,4BAA4B,CAAC;AAE1E;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,EAAE,kBAyG3C,CAAC"}

package/dist/packages/core/src/application/workflows/application-creation.workflow.js

@@ -0,0 +1,138 @@
+/**
+ * Application-creation workflow definition.
+ *
+ * The eight steps Shep walks every new application through, with the
+ * friendly non-technical title/description the user sees in the
+ * tracker card AND the focused agent-facing prompt the orchestrator
+ * sends for that step.
+ *
+ * History note: an earlier version had separate `plan` and `content`
+ * steps. They produced agent text confirmations with no actual tool
+ * work, leaving lonely "title-only" cards in the tracker. Both have
+ * been folded into the `components` step which now plans, builds,
+ * and writes real content in a single agent turn.
+ *
+ * Key design notes:
+ *   - The orchestrator (`RunWorkflowUseCase`) sends each step's
+ *     `prompt` as a user turn against the SAME interactive session,
+ *     so the agent has full history from the previous steps.
+ *   - The very first step's prompt is decorated with a brief-read
+ *     directive by `CreateApplicationUseCase` so the agent reads
+ *     `SHEP_BRIEF.md` before doing anything else. Subsequent steps
+ *     can just say "do X" because the brief is already loaded.
+ *   - Titles and descriptions are user-facing. Never put code, paths,
+ *     or jargon in them — they show in step cards next to avatars.
+ */
+export const APPLICATION_CREATION_WORKFLOW_ID = 'application-creation-v2';
+/**
+ * The canonical application-creation workflow. Bumping the `id`
+ * suffix ("-v1" → "-v2") triggers a new set of step rows for any
+ * session that starts after the bump, without touching existing
+ * data. Old rows remain queryable by their old workflow id.
+ */
+export const APPLICATION_CREATION_WORKFLOW = {
+    id: APPLICATION_CREATION_WORKFLOW_ID,
+    steps: [
+        {
+            stepKey: 'scaffold',
+            title: 'Setting up your project',
+            description: 'Creating the foundation files',
+            prompt: [
+                'Your task for this step is ONLY to scaffold the Vite + React + TypeScript project.',
+                '',
+                'Run this exact command as your first tool call, no discovery commands before it:',
+                '',
+                '```',
+                'npm create vite@latest . -- --template react-ts',
+                '```',
+                '',
+                '(note the dot — scaffold INTO the current directory).',
+                '',
+                'Then run `npm install`. Do not write any source files in this step. Do not touch Tailwind or any other dependency — that is the next step. When `npm install` finishes cleanly, reply with a short plain-English confirmation (one sentence).',
+            ].join('\n'),
+        },
+        {
+            stepKey: 'deps',
+            title: 'Installing design tools',
+            description: 'Adding Tailwind and essentials',
+            prompt: [
+                'Install Tailwind CSS via the official Vite guide and wire it into `src/index.css` / `tailwind.config.js` so it actually compiles.',
+                '',
+                'Then add the minimum extras the app will need (from this list, only what the app will actually use): `react-router-dom`, `react-hook-form`, `zod`, `lucide-react`, `clsx`, `tailwind-merge`. Keep `package.json` lean — no speculative libraries.',
+                '',
+                'When done, reply with a short plain-English confirmation (one sentence).',
+            ].join('\n'),
+        },
+        {
+            stepKey: 'components',
+            title: 'Building the pieces',
+            description: 'Designing and creating reusable parts',
+            prompt: [
+                "Plan the app first — what screens it has, what reusable components those screens need, what data shapes flow between them. Keep the plan in your head; do NOT share it with the user, the next step's output is what they will see.",
+                '',
+                'Then build the leaf components bottom-up. Every component is a real `.tsx` file under `src/`. Small reusable pieces first, then larger compositions. Do NOT wire routing or full-page composition here — that is the next step.',
+                '',
+                'Populate every component with realistic, hand-crafted content the moment you create it: real-sounding names, dates, prices, copy. Lorem ipsum is FORBIDDEN.',
+                '',
+                'When the components are drafted with their real content, reply with a one-sentence confirmation.',
+            ].join('\n'),
+        },
+        {
+            stepKey: 'wire',
+            title: 'Connecting everything',
+            description: 'Wiring navigation and forms',
+            prompt: [
+                'Wire the app together: routing, forms, state, any mock data flow. The app should feel like a coherent whole, not a page of disconnected components.',
+                '',
+                'Reply with a one-sentence confirmation when the wiring is done.',
+            ].join('\n'),
+        },
+        {
+            stepKey: 'style',
+            title: 'Polishing the look',
+            description: 'Applying colors, spacing, and motion',
+            prompt: [
+                'Polish the visuals: cohesive Tailwind palette, consistent spacing scale, typography, hover states, transitions. Mobile-first responsive. No inline `<style>` blocks.',
+                '',
+                'Reply with a one-sentence confirmation when the polish pass is finished.',
+            ].join('\n'),
+        },
+        {
+            stepKey: 'verify',
+            title: 'Double-checking',
+            description: 'Making sure it runs cleanly',
+            prompt: [
+                "Run `npm run build` (or the project's typecheck) and fix EVERY error and warning. The app MUST start cleanly with `npm run dev` on the very first try — no errors in the browser console, no unresolved imports.",
+                '',
+                'When the build is clean, reply with a one-sentence confirmation.',
+            ].join('\n'),
+        },
+        {
+            stepKey: 'commit',
+            title: 'Saving a snapshot',
+            description: 'Committing the initial build',
+            prompt: [
+                'Save a git snapshot of the whole initial build so the user can easily roll back later.',
+                '',
+                'Run these commands in order, from the project root:',
+                '',
+                '1. `git init` — safe no-op if the directory is already a repo.',
+                '2. `git config user.email "shep@shep.bot"` and `git config user.name "Shep"` — repo-local identity so the commit succeeds even when the host machine has no global git config.',
+                '3. `git add -A` — stage every file, including node_modules is fine, `.gitignore` from the Vite template already excludes it.',
+                '4. `git commit -m "Initial Shep build"` — single commit holding the whole scaffold.',
+                '',
+                'If any command fails, do NOT give up — fix the issue (for example, configure missing identity) and retry. Only after the commit lands successfully, reply with a one-sentence plain-English confirmation. Do NOT push to any remote.',
+            ].join('\n'),
+        },
+        {
+            stepKey: 'report',
+            title: 'Your app is ready',
+            description: 'Summary of what was built',
+            prompt: [
+                'Write a short, friendly, plain-language summary for the user: what you built, what they can do in it, and how to view it. No tech jargon — pretend the user has never touched a terminal.',
+                '',
+                'This is the final step; your reply IS the summary.',
+            ].join('\n'),
+        },
+    ],
+};

package/dist/packages/core/src/domain/generated/output.d.ts

@@ -1679,6 +1679,48 @@ export type Repository = SoftDeletableEntity & {
      */
     upstreamUrl?: string;
 };
+export declare enum ApplicationStatus {
+    Idle = "Idle",
+    Active = "Active",
+    Error = "Error"
+}
+/**
+ * A persistent AI-powered application workspace
+ */
+export type Application = SoftDeletableEntity & {
+    /**
+     * Human-readable application name
+     */
+    name: string;
+    /**
+     * URL-friendly identifier (unique)
+     */
+    slug: string;
+    /**
+     * Original user prompt / purpose description
+     */
+    description: string;
+    /**
+     * Absolute path to the primary repository
+     */
+    repositoryPath: string;
+    /**
+     * Additional linked repository/directory paths (JSON array)
+     */
+    additionalPaths: string[];
+    /**
+     * Chosen agent executor type override
+     */
+    agentType?: string;
+    /**
+     * Chosen model override
+     */
+    modelOverride?: string;
+    /**
+     * Current application status
+     */
+    status: ApplicationStatus;
+};
 /**
  * Single installation suggestion for a tool
  */
@@ -2365,6 +2407,66 @@ export type InteractiveMessage = BaseEntity & {
      * Full message content (finalised after streaming for assistant messages)
      */
     content: string;
+    /**
+     * Optional workflow step ID this message was produced for
+     */
+    stepId?: string;
+};
+export declare enum WorkflowStepStatus {
+    pending = "pending",
+    running = "running",
+    done = "done",
+    failed = "failed",
+    interrupted = "interrupted"
+}
+/**
+ * A persisted step of a multi-step workflow executed inside an interactive session
+ */
+export type WorkflowStep = BaseEntity & {
+    /**
+     * Parent interactive session id
+     */
+    sessionId: string;
+    /**
+     * Polymorphic scope key: matches InteractiveMessage.featureId
+     */
+    featureId: string;
+    /**
+     * Logical workflow id (e.g. 'application-creation-v1')
+     */
+    workflowId: string;
+    /**
+     * Stable key inside the workflow (e.g. 'scaffold', 'deps')
+     */
+    stepKey: string;
+    /**
+     * Order of this step within the workflow, starting at 0
+     */
+    stepIndex: number;
+    /**
+     * Non-technical title shown to the user
+     */
+    title: string;
+    /**
+     * Non-technical subtitle shown to the user
+     */
+    description: string;
+    /**
+     * Current lifecycle status
+     */
+    status: WorkflowStepStatus;
+    /**
+     * When the step transitioned to running
+     */
+    startedAt?: any;
+    /**
+     * When the step transitioned to done/failed/interrupted
+     */
+    finishedAt?: any;
+    /**
+     * JSON blob with summary, details, error — populated when done/failed
+     */
+    metadata?: string;
 };
 /**
  * A selectable option within a PRD questionnaire question