@qotaq/lalphgram 0.1.0

package/dist/cjs/services/ChatMachine.js

@@ -0,0 +1,873 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.chatMachine = exports.UserMessage = exports.ReadyFlags = exports.REFACTOR_BUTTON_LABEL = exports.PlanTextOutput = exports.PlanSpecUpdatedReq = exports.PlanSpecCreatedReq = exports.PlanQuestionReceived = exports.PlanFailedReq = exports.PlanCompletedReq = exports.PlanAwaitingInputReq = exports.PlanAnalysisReadyReq = exports.PLAN_BUTTON_LABEL = exports.OTHER_BUTTON_LABEL = exports.NEW_PROJECT_BUTTON_LABEL = exports.INTERRUPT_BUTTON_LABEL = exports.IDLE_KEYBOARD = exports.FEATURE_BUTTON_LABEL = exports.DONE_BUTTON_LABEL = exports.DISCARD_BUTTON_LABEL = exports.ChatState = exports.BUG_BUTTON_LABEL = exports.BUFFER_BUTTON_LABEL = exports.APPROVE_BUTTON_LABEL = exports.ABORT_BUTTON_LABEL = void 0;
+var Machine = _interopRequireWildcard(require("@effect/experimental/Machine"));
+var _effect = require("effect");
+var _AnalysisPrompts = require("../lib/AnalysisPrompts.js");
+var _TelegramFormatter = require("../lib/TelegramFormatter.js");
+var _MessengerAdapter = require("./MessengerAdapter/MessengerAdapter.js");
+var _PlanOverviewUploader = require("./PlanOverviewUploader.js");
+var _PlanSession = require("./PlanSession.js");
+var _ProjectStore = require("./ProjectStore.js");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * Chat state machine using @effect/experimental/Machine
+ * @since 1.0.0
+ */
+
+// ── Button labels ────────────────────────────────────────────────
+const PLAN_BUTTON_LABEL = exports.PLAN_BUTTON_LABEL = "Plan";
+const DONE_BUTTON_LABEL = exports.DONE_BUTTON_LABEL = "Done";
+const FEATURE_BUTTON_LABEL = exports.FEATURE_BUTTON_LABEL = "Feature";
+const BUG_BUTTON_LABEL = exports.BUG_BUTTON_LABEL = "Bug";
+const REFACTOR_BUTTON_LABEL = exports.REFACTOR_BUTTON_LABEL = "Refactor";
+const OTHER_BUTTON_LABEL = exports.OTHER_BUTTON_LABEL = "Other";
+const APPROVE_BUTTON_LABEL = exports.APPROVE_BUTTON_LABEL = "Approve";
+const BUFFER_BUTTON_LABEL = exports.BUFFER_BUTTON_LABEL = "Buffer";
+const INTERRUPT_BUTTON_LABEL = exports.INTERRUPT_BUTTON_LABEL = "Interrupt";
+const DISCARD_BUTTON_LABEL = exports.DISCARD_BUTTON_LABEL = "Discard";
+const ABORT_BUTTON_LABEL = exports.ABORT_BUTTON_LABEL = "Abort";
+const NEW_PROJECT_BUTTON_LABEL = exports.NEW_PROJECT_BUTTON_LABEL = "New project";
+const MY_ANSWER_BUTTON_LABEL = "Custom answer";
+const BACK_BUTTON_LABEL = "Back";
+const PLAN_TYPE_LABELS = [FEATURE_BUTTON_LABEL, BUG_BUTTON_LABEL, REFACTOR_BUTTON_LABEL, OTHER_BUTTON_LABEL];
+// ── Keyboards ────────────────────────────────────────────────────
+const IDLE_KEYBOARD = exports.IDLE_KEYBOARD = [{
+  label: PLAN_BUTTON_LABEL
+}, {
+  label: NEW_PROJECT_BUTTON_LABEL
+}];
+const COLLECTING_KEYBOARD = [{
+  label: DONE_BUTTON_LABEL
+}, {
+  label: ABORT_BUTTON_LABEL
+}];
+const SESSION_KEYBOARD = [{
+  label: ABORT_BUTTON_LABEL
+}];
+const SPEC_READY_KEYBOARD = [{
+  label: APPROVE_BUTTON_LABEL
+}, {
+  label: ABORT_BUTTON_LABEL
+}];
+class ReadyFlags extends _effect.Data.Class {}
+exports.ReadyFlags = ReadyFlags;
+const ChatState = exports.ChatState = /*#__PURE__*/_effect.Data.taggedEnum();
+const initialSessionRunning = (projectId, planType) => ChatState.SessionRunning({
+  projectId,
+  planType,
+  pendingAnswerCount: 0,
+  pendingOptionLabels: new Set(),
+  answersBuffer: [],
+  awaitingFreeTextAnswer: false,
+  lastQuestionMessage: _effect.Option.none(),
+  readyFlags: new ReadyFlags({
+    spec: false,
+    analysis: false,
+    idle: false
+  }),
+  analysisFollowUpSent: false
+});
+// ── Request types ────────────────────────────────────────────────
+class UserMessage extends /*#__PURE__*/_effect.Schema.TaggedRequest()("UserMessage", {
+  failure: _effect.Schema.Never,
+  success: _effect.Schema.Void,
+  payload: {
+    text: _effect.Schema.String
+  }
+}) {}
+exports.UserMessage = UserMessage;
+class PlanTextOutput extends /*#__PURE__*/_effect.Schema.TaggedRequest()("PlanTextOutput", {
+  failure: _effect.Schema.Never,
+  success: _effect.Schema.Void,
+  payload: {
+    text: _effect.Schema.String
+  }
+}) {}
+exports.PlanTextOutput = PlanTextOutput;
+class PlanQuestionReceived extends /*#__PURE__*/_effect.Schema.TaggedRequest()("PlanQuestionReceived", {
+  failure: _effect.Schema.Never,
+  success: _effect.Schema.Void,
+  payload: {
+    questions: /*#__PURE__*/_effect.Schema.Array(/*#__PURE__*/_effect.Schema.Struct({
+      question: _effect.Schema.String,
+      header: /*#__PURE__*/_effect.Schema.optional(_effect.Schema.String),
+      options: /*#__PURE__*/_effect.Schema.optional(/*#__PURE__*/_effect.Schema.Array(/*#__PURE__*/_effect.Schema.Struct({
+        label: _effect.Schema.String
+      })))
+    }))
+  }
+}) {}
+exports.PlanQuestionReceived = PlanQuestionReceived;
+class PlanSpecCreatedReq extends /*#__PURE__*/_effect.Schema.TaggedRequest()("PlanSpecCreatedReq", {
+  failure: _effect.Schema.Never,
+  success: _effect.Schema.Void,
+  payload: {}
+}) {}
+exports.PlanSpecCreatedReq = PlanSpecCreatedReq;
+class PlanSpecUpdatedReq extends /*#__PURE__*/_effect.Schema.TaggedRequest()("PlanSpecUpdatedReq", {
+  failure: _effect.Schema.Never,
+  success: _effect.Schema.Void,
+  payload: {}
+}) {}
+exports.PlanSpecUpdatedReq = PlanSpecUpdatedReq;
+class PlanAnalysisReadyReq extends /*#__PURE__*/_effect.Schema.TaggedRequest()("PlanAnalysisReadyReq", {
+  failure: _effect.Schema.Never,
+  success: _effect.Schema.Void,
+  payload: {}
+}) {}
+exports.PlanAnalysisReadyReq = PlanAnalysisReadyReq;
+class PlanAwaitingInputReq extends /*#__PURE__*/_effect.Schema.TaggedRequest()("PlanAwaitingInputReq", {
+  failure: _effect.Schema.Never,
+  success: _effect.Schema.Void,
+  payload: {}
+}) {}
+exports.PlanAwaitingInputReq = PlanAwaitingInputReq;
+class PlanCompletedReq extends /*#__PURE__*/_effect.Schema.TaggedRequest()("PlanCompletedReq", {
+  failure: _effect.Schema.Never,
+  success: _effect.Schema.Void,
+  payload: {}
+}) {}
+exports.PlanCompletedReq = PlanCompletedReq;
+class PlanFailedReq extends /*#__PURE__*/_effect.Schema.TaggedRequest()("PlanFailedReq", {
+  failure: _effect.Schema.Never,
+  success: _effect.Schema.Void,
+  payload: {
+    message: _effect.Schema.String
+  }
+}) {}
+exports.PlanFailedReq = PlanFailedReq;
+const reply = state => [undefined, state];
+const chatMachine = exports.chatMachine = /*#__PURE__*/Machine.make(/*#__PURE__*/_effect.Effect.gen(function* () {
+  // Capture services at init (closures — handlers have R = never)
+  const notifier = yield* _MessengerAdapter.MessengerAdapter;
+  const planSession = yield* _PlanSession.PlanSession;
+  const projectStore = yield* _ProjectStore.ProjectStore;
+  const planOverviewUploader = yield* _PlanOverviewUploader.PlanOverviewUploader;
+  // ── Helpers ────────────────────────────────────────────────
+  const readSpecFiles = planType => planType === "Feature" ? planSession.readFeatureAnalysis.pipe(_effect.Effect.map(files => [{
+    name: "analysis.md",
+    content: files.analysis,
+    mermaid: false
+  }, {
+    name: "services.mmd",
+    content: files.services,
+    mermaid: true
+  }, {
+    name: "test.md",
+    content: files.test,
+    mermaid: false
+  }])) : planType === "Bug" ? planSession.readBugAnalysis.pipe(_effect.Effect.map(files => [{
+    name: "analysis.md",
+    content: files.analysis,
+    mermaid: false
+  }])) : planType === "Refactor" ? planSession.readRefactorAnalysis.pipe(_effect.Effect.map(files => [{
+    name: "analysis.md",
+    content: files.analysis,
+    mermaid: false
+  }])) : planSession.readDefaultAnalysis.pipe(_effect.Effect.map(files => [{
+    name: "analysis.md",
+    content: files.analysis,
+    mermaid: false
+  }]));
+  const sendSpecFilesRaw = files => _effect.Effect.forEach(files, file => {
+    const formatted = file.mermaid ? (0, _TelegramFormatter.markdownToTelegramHtml)(`\`\`\`mermaid\n${file.content}\n\`\`\``) : (0, _TelegramFormatter.markdownToTelegramHtml)(file.content);
+    const text = `<b>${file.name}</b>\n${formatted}`;
+    return _effect.Effect.forEach((0, _TelegramFormatter.splitMessage)(text), chunk => notifier.sendMessage(chunk));
+  });
+  const sendSpecFiles = planType => _effect.Effect.gen(function* () {
+    const files = yield* readSpecFiles(planType);
+    yield* planOverviewUploader.upload({
+      files,
+      description: `Spec: ${planType}`
+    }).pipe(_effect.Effect.tap(result => notifier.sendMessage(`<a href="${result.url}">View spec</a>`)), _effect.Effect.catchTag("PlanOverviewUploaderError", err => _effect.Effect.gen(function* () {
+      yield* _effect.Effect.logError(`Spec upload failed, sending raw: ${err.message}`);
+      yield* sendSpecFilesRaw(files);
+    })));
+  });
+  const rejectSession = planSession.reject.pipe(_effect.Effect.tapError(err => _effect.Effect.logError(`Plan abort error: ${err.message}`)), _effect.Effect.orElseSucceed(() => undefined));
+  const abortToIdle = hasSession => _effect.Effect.gen(function* () {
+    if (hasSession) {
+      yield* rejectSession;
+    }
+    yield* _effect.Effect.log("Plan aborted");
+    yield* notifier.sendMessage({
+      text: "Plan aborted.",
+      replyKeyboard: IDLE_KEYBOARD
+    });
+  });
+  const submitAnswers = answers => _effect.Effect.gen(function* () {
+    const combined = answers.join("\n");
+    yield* _effect.Effect.log("Flushing batched answers to plan session");
+    yield* planSession.answer(combined).pipe(_effect.Effect.tapError(err => _effect.Effect.logError(`Plan answer error: ${err.message}`)), _effect.Effect.orElseSucceed(() => undefined));
+  });
+  const showFollowUpChoice = (text, projectId, planType, readyFlags, analysisFollowUpSent) => _effect.Effect.gen(function* () {
+    yield* _effect.Effect.log("Holding follow-up message, showing buffer/interrupt buttons");
+    yield* notifier.sendMessage({
+      text: "Send as follow-up or interrupt Claude?",
+      options: [{
+        label: BUFFER_BUTTON_LABEL
+      }, {
+        label: INTERRUPT_BUTTON_LABEL
+      }, {
+        label: DISCARD_BUTTON_LABEL
+      }]
+    });
+    return ChatState.AwaitingFollowUpDecision({
+      projectId,
+      planType,
+      message: text,
+      readyFlags,
+      analysisFollowUpSent
+    });
+  });
+  const checkAllReady = (projectId, planType, flags, analysisFollowUpSent) => _effect.Effect.gen(function* () {
+    if (!flags.spec || !flags.analysis || !flags.idle) {
+      return ChatState.SessionRunning({
+        projectId,
+        planType,
+        pendingAnswerCount: 0,
+        pendingOptionLabels: new Set(),
+        answersBuffer: [],
+        awaitingFreeTextAnswer: false,
+        lastQuestionMessage: _effect.Option.none(),
+        readyFlags: flags,
+        analysisFollowUpSent
+      });
+    }
+    yield* sendSpecFiles(planType).pipe(_effect.Effect.catchAll(err => _effect.Effect.logError(`Failed to send spec files: ${String(err)}`)));
+    yield* notifier.sendMessage({
+      text: "Spec ready. Reply with questions or approve to proceed.",
+      replyKeyboard: SPEC_READY_KEYBOARD
+    }).pipe(_effect.Effect.orElseSucceed(() => undefined));
+    return ChatState.SpecReady({
+      projectId,
+      planType,
+      readyFlags: flags,
+      analysisFollowUpSent
+    });
+  });
+  const maybeAnalysisFollowUp = (planType, alreadySent) => alreadySent ? _effect.Effect.succeed(true) : planSession.sendFollowUp((0, _AnalysisPrompts.getAnalysisPrompt)(planType)).pipe(_effect.Effect.tapError(err => _effect.Effect.logError(`Analysis follow-up error: ${err.message}`)), _effect.Effect.orElseSucceed(() => undefined), _effect.Effect.as(true));
+  /**
+   * Extract projectId, planType, readyFlags, and analysisFollowUpSent from any
+   * "active session" state (SessionRunning, AwaitingFollowUpDecision, SpecReady).
+   */
+  const extractActiveState = state => {
+    switch (state._tag) {
+      case "SessionRunning":
+        return _effect.Option.some({
+          projectId: state.projectId,
+          planType: state.planType,
+          readyFlags: state.readyFlags,
+          analysisFollowUpSent: state.analysisFollowUpSent
+        });
+      case "AwaitingFollowUpDecision":
+        return _effect.Option.some({
+          projectId: state.projectId,
+          planType: state.planType,
+          readyFlags: state.readyFlags,
+          analysisFollowUpSent: state.analysisFollowUpSent
+        });
+      case "SpecReady":
+        return _effect.Option.some({
+          projectId: state.projectId,
+          planType: state.planType,
+          readyFlags: state.readyFlags,
+          analysisFollowUpSent: state.analysisFollowUpSent
+        });
+      default:
+        return _effect.Option.none();
+    }
+  };
+  // ── Procedure handlers ─────────────────────────────────────
+  return Machine.procedures.make(ChatState.Idle()).pipe(
+  // ── UserMessage ────────────────────────────────────────
+  Machine.procedures.add()("UserMessage", ctx => _effect.Effect.gen(function* () {
+    const {
+      state
+    } = ctx;
+    const text = ctx.request.text;
+    yield* _effect.Effect.log(`Incoming message: ${text}`);
+    switch (state._tag) {
+      case "Idle":
+        {
+          if (text === PLAN_BUTTON_LABEL) {
+            const projects = yield* projectStore.listProjects.pipe(_effect.Effect.orElseSucceed(() => []));
+            if (projects.length === 0) {
+              yield* notifier.sendMessage("No projects. Create one first.");
+              return reply(state);
+            }
+            if (projects.length === 1) {
+              yield* _effect.Effect.log("Single project auto-selected").pipe(_effect.Effect.annotateLogs("projectId", projects[0].id));
+              yield* notifier.sendMessage({
+                text: "What type of change?",
+                options: [...PLAN_TYPE_LABELS.map(label => ({
+                  label
+                })), {
+                  label: ABORT_BUTTON_LABEL
+                }]
+              });
+              return reply(ChatState.SelectingPlanType({
+                projectId: projects[0].id
+              }));
+            }
+            yield* notifier.sendMessage({
+              text: "Select a project:",
+              options: [...projects.map(p => ({
+                label: p.id
+              })), {
+                label: NEW_PROJECT_BUTTON_LABEL
+              }, {
+                label: ABORT_BUTTON_LABEL
+              }]
+            });
+            return reply(ChatState.SelectingProject());
+          }
+          if (text === NEW_PROJECT_BUTTON_LABEL) {
+            yield* notifier.sendMessage("Enter project name:");
+            return reply(ChatState.CreatingProject({
+              step: "Name",
+              data: {},
+              continueWithPlan: false
+            }));
+          }
+          return reply(state);
+        }
+      case "SelectingProject":
+        {
+          if (text === ABORT_BUTTON_LABEL) {
+            yield* notifier.sendMessage({
+              text: "Plan aborted.",
+              replyKeyboard: IDLE_KEYBOARD
+            });
+            return reply(ChatState.Idle());
+          }
+          if (text === NEW_PROJECT_BUTTON_LABEL) {
+            yield* notifier.sendMessage("Enter project name:");
+            return reply(ChatState.CreatingProject({
+              step: "Name",
+              data: {},
+              continueWithPlan: true
+            }));
+          }
+          yield* _effect.Effect.log("Project selected").pipe(_effect.Effect.annotateLogs("projectId", text));
+          yield* notifier.sendMessage({
+            text: "What type of change?",
+            options: [...PLAN_TYPE_LABELS.map(label => ({
+              label
+            })), {
+              label: ABORT_BUTTON_LABEL
+            }]
+          });
+          return reply(ChatState.SelectingPlanType({
+            projectId: text
+          }));
+        }
+      case "SelectingPlanType":
+        {
+          if (text === ABORT_BUTTON_LABEL) {
+            yield* notifier.sendMessage({
+              text: "Plan aborted.",
+              replyKeyboard: IDLE_KEYBOARD
+            });
+            return reply(ChatState.Idle());
+          }
+          if (PLAN_TYPE_LABELS.includes(text)) {
+            yield* _effect.Effect.log("Plan type selected, collection started").pipe(_effect.Effect.annotateLogs("planType", text));
+            yield* notifier.sendMessage({
+              text: "Describe what you'd like to plan. Tap <b>Done</b> when ready.",
+              replyKeyboard: COLLECTING_KEYBOARD
+            });
+            return reply(ChatState.CollectingPlan({
+              projectId: state.projectId,
+              planType: text,
+              buffer: []
+            }));
+          }
+          return reply(state);
+        }
+      case "CollectingPlan":
+        {
+          if (text === ABORT_BUTTON_LABEL) {
+            yield* abortToIdle(false);
+            return reply(ChatState.Idle());
+          }
+          if (text === DONE_BUTTON_LABEL) {
+            const joinedText = state.buffer.join("\n");
+            if (joinedText.trim().length === 0) {
+              yield* _effect.Effect.log("Plan collection done with empty buffer");
+              yield* notifier.sendMessage("No plan description provided.");
+              return reply(state);
+            }
+            yield* _effect.Effect.log("Plan collection done, starting session").pipe(_effect.Effect.annotateLogs("planText", joinedText));
+            const totalProjects = yield* projectStore.listProjects.pipe(_effect.Effect.map(ps => ps.length), _effect.Effect.orElseSucceed(() => 1));
+            yield* planSession.start(joinedText, totalProjects > 1 ? state.projectId : undefined).pipe(_effect.Effect.tapError(err => notifier.sendMessage(`Plan error: ${err.message}`)), _effect.Effect.orElseSucceed(() => undefined));
+            yield* notifier.sendMessage({
+              text: "Planning started...",
+              replyKeyboard: SESSION_KEYBOARD
+            });
+            return reply(initialSessionRunning(state.projectId, state.planType));
+          }
+          yield* _effect.Effect.log("Buffering plan message").pipe(_effect.Effect.annotateLogs("bufferedText", text));
+          yield* notifier.sendMessage("✓ Added. Tap <b>Done</b> when ready.");
+          return reply(ChatState.CollectingPlan({
+            projectId: state.projectId,
+            planType: state.planType,
+            buffer: [...state.buffer, text]
+          }));
+        }
+      case "SessionRunning":
+        {
+          if (text === ABORT_BUTTON_LABEL) {
+            yield* abortToIdle(true);
+            return reply(ChatState.Idle());
+          }
+          if (state.pendingAnswerCount > 0 && state.pendingOptionLabels.has(text)) {
+            if (text === MY_ANSWER_BUTTON_LABEL) {
+              yield* notifier.sendMessage({
+                text: "Type your answer:",
+                options: [{
+                  label: BACK_BUTTON_LABEL
+                }]
+              });
+              return reply(ChatState.SessionRunning({
+                ...state,
+                awaitingFreeTextAnswer: true
+              }));
+            }
+            if (text === BACK_BUTTON_LABEL) {
+              if (_effect.Option.isSome(state.lastQuestionMessage)) {
+                yield* notifier.sendMessage(state.lastQuestionMessage.value);
+              }
+              return reply(ChatState.SessionRunning({
+                ...state,
+                awaitingFreeTextAnswer: false
+              }));
+            }
+            const newBuffer = [...state.answersBuffer, text];
+            const newPending = state.pendingAnswerCount - 1;
+            if (newPending <= 0) {
+              yield* _effect.Effect.log("Buffering answer");
+              yield* submitAnswers(newBuffer);
+              return reply(ChatState.SessionRunning({
+                ...state,
+                awaitingFreeTextAnswer: false,
+                answersBuffer: [],
+                pendingAnswerCount: 0,
+                pendingOptionLabels: new Set(),
+                readyFlags: new ReadyFlags({
+                  ...state.readyFlags,
+                  idle: false
+                })
+              }));
+            }
+            yield* _effect.Effect.log("Buffering answer");
+            return reply(ChatState.SessionRunning({
+              ...state,
+              awaitingFreeTextAnswer: false,
+              answersBuffer: newBuffer,
+              pendingAnswerCount: newPending
+            }));
+          }
+          if (state.awaitingFreeTextAnswer) {
+            const newBuffer = [...state.answersBuffer, text];
+            const newPending = state.pendingAnswerCount - 1;
+            if (newPending <= 0) {
+              yield* _effect.Effect.log("Buffering free-text answer");
+              yield* submitAnswers(newBuffer);
+              return reply(ChatState.SessionRunning({
+                ...state,
+                awaitingFreeTextAnswer: false,
+                answersBuffer: [],
+                pendingAnswerCount: 0,
+                pendingOptionLabels: new Set(),
+                readyFlags: new ReadyFlags({
+                  ...state.readyFlags,
+                  idle: false
+                })
+              }));
+            }
+            yield* _effect.Effect.log("Buffering free-text answer");
+            return reply(ChatState.SessionRunning({
+              ...state,
+              awaitingFreeTextAnswer: false,
+              answersBuffer: newBuffer,
+              pendingAnswerCount: newPending
+            }));
+          }
+          const idle = yield* planSession.isIdle;
+          if (idle) {
+            yield* planSession.sendFollowUp(text).pipe(_effect.Effect.tap(() => notifier.sendMessage("Follow-up sent.")), _effect.Effect.tapError(err => _effect.Effect.logError(`Plan follow-up error: ${err.message}`)), _effect.Effect.orElseSucceed(() => undefined));
+            return reply(ChatState.SessionRunning({
+              ...state,
+              readyFlags: new ReadyFlags({
+                ...state.readyFlags,
+                idle: false
+              })
+            }));
+          }
+          const newState = yield* showFollowUpChoice(text, state.projectId, state.planType, state.readyFlags, state.analysisFollowUpSent);
+          return reply(newState);
+        }
+      case "AwaitingFollowUpDecision":
+        {
+          if (text === BUFFER_BUTTON_LABEL) {
+            yield* _effect.Effect.log("Buffering follow-up message");
+            yield* planSession.sendFollowUp(state.message).pipe(_effect.Effect.tap(() => notifier.sendMessage("Message buffered — Claude will process it shortly.")), _effect.Effect.tapError(err => _effect.Effect.logError(`Plan follow-up error: ${err.message}`)), _effect.Effect.orElseSucceed(() => undefined));
+            return reply(ChatState.SessionRunning({
+              projectId: state.projectId,
+              planType: state.planType,
+              pendingAnswerCount: 0,
+              pendingOptionLabels: new Set(),
+              answersBuffer: [],
+              awaitingFreeTextAnswer: false,
+              lastQuestionMessage: _effect.Option.none(),
+              readyFlags: new ReadyFlags({
+                ...state.readyFlags,
+                idle: false
+              }),
+              analysisFollowUpSent: state.analysisFollowUpSent
+            }));
+          }
+          if (text === INTERRUPT_BUTTON_LABEL) {
+            yield* _effect.Effect.log("Interrupting Claude with follow-up message");
+            yield* planSession.interrupt(state.message).pipe(_effect.Effect.tap(() => notifier.sendMessage("Claude interrupted — processing your message now.")), _effect.Effect.tapError(err => _effect.Effect.logError(`Plan interrupt error: ${err.message}`)), _effect.Effect.orElseSucceed(() => undefined));
+            return reply(ChatState.SessionRunning({
+              projectId: state.projectId,
+              planType: state.planType,
+              pendingAnswerCount: 0,
+              pendingOptionLabels: new Set(),
+              answersBuffer: [],
+              awaitingFreeTextAnswer: false,
+              lastQuestionMessage: _effect.Option.none(),
+              readyFlags: new ReadyFlags({
+                ...state.readyFlags,
+                idle: false
+              }),
+              analysisFollowUpSent: state.analysisFollowUpSent
+            }));
+          }
+          if (text === DISCARD_BUTTON_LABEL) {
+            yield* _effect.Effect.log("Follow-up message discarded");
+            yield* notifier.sendMessage("Message discarded.");
+            return reply(ChatState.SessionRunning({
+              projectId: state.projectId,
+              planType: state.planType,
+              pendingAnswerCount: 0,
+              pendingOptionLabels: new Set(),
+              answersBuffer: [],
+              awaitingFreeTextAnswer: false,
+              lastQuestionMessage: _effect.Option.none(),
+              readyFlags: state.readyFlags,
+              analysisFollowUpSent: state.analysisFollowUpSent
+            }));
+          }
+          if (text === ABORT_BUTTON_LABEL) {
+            yield* abortToIdle(true);
+            return reply(ChatState.Idle());
+          }
+          return reply(state);
+        }
+      case "SpecReady":
+        {
+          if (text === APPROVE_BUTTON_LABEL) {
+            yield* _effect.Effect.log("User approved task creation");
+            yield* planSession.approve.pipe(_effect.Effect.tapError(err => _effect.Effect.logError(`Plan approve error: ${err.message}`)), _effect.Effect.orElseSucceed(() => undefined));
+            yield* notifier.sendMessage({
+              text: "Spec approved.",
+              replyKeyboard: IDLE_KEYBOARD
+            });
+            return reply(ChatState.Idle());
+          }
+          if (text === ABORT_BUTTON_LABEL) {
+            yield* abortToIdle(true);
+            return reply(ChatState.Idle());
+          }
+          const idleSpec = yield* planSession.isIdle;
+          if (idleSpec) {
+            yield* planSession.sendFollowUp(text).pipe(_effect.Effect.tap(() => notifier.sendMessage("Follow-up sent.")), _effect.Effect.tapError(err => _effect.Effect.logError(`Plan follow-up error: ${err.message}`)), _effect.Effect.orElseSucceed(() => undefined));
+            return reply(ChatState.SessionRunning({
+              projectId: state.projectId,
+              planType: state.planType,
+              pendingAnswerCount: 0,
+              pendingOptionLabels: new Set(),
+              answersBuffer: [],
+              awaitingFreeTextAnswer: false,
+              lastQuestionMessage: _effect.Option.none(),
+              readyFlags: new ReadyFlags({
+                ...state.readyFlags,
+                idle: false
+              }),
+              analysisFollowUpSent: state.analysisFollowUpSent
+            }));
+          }
+          const followUpState = yield* showFollowUpChoice(text, state.projectId, state.planType, state.readyFlags, state.analysisFollowUpSent);
+          return reply(followUpState);
+        }
+      case "CreatingProject":
+        {
+          if (text === ABORT_BUTTON_LABEL) {
+            yield* notifier.sendMessage({
+              text: "Project creation cancelled.",
+              replyKeyboard: IDLE_KEYBOARD
+            });
+            return reply(ChatState.Idle());
+          }
+          switch (state.step) {
+            case "Name":
+              {
+                yield* notifier.sendMessage({
+                  text: "Concurrency (tasks in parallel):",
+                  options: [{
+                    label: "1"
+                  }, {
+                    label: "2"
+                  }, {
+                    label: "3"
+                  }, {
+                    label: "4"
+                  }, {
+                    label: ABORT_BUTTON_LABEL
+                  }]
+                });
+                return reply(ChatState.CreatingProject({
+                  ...state,
+                  step: "Concurrency",
+                  data: {
+                    ...state.data,
+                    name: text
+                  }
+                }));
+              }
+            case "Concurrency":
+              {
+                const n = Number(text);
+                if (isNaN(n) || n < 1) return reply(state);
+                yield* notifier.sendMessage({
+                  text: "Target branch (type branch name or skip):",
+                  options: [{
+                    label: "Skip"
+                  }, {
+                    label: ABORT_BUTTON_LABEL
+                  }]
+                });
+                return reply(ChatState.CreatingProject({
+                  ...state,
+                  step: "TargetBranch",
+                  data: {
+                    ...state.data,
+                    concurrency: n
+                  }
+                }));
+              }
+            case "TargetBranch":
+              {
+                const targetBranch = text === "Skip" ? null : text;
+                yield* notifier.sendMessage({
+                  text: "Git flow:",
+                  options: [{
+                    label: "PR"
+                  }, {
+                    label: "Commit"
+                  }, {
+                    label: ABORT_BUTTON_LABEL
+                  }]
+                });
+                return reply(ChatState.CreatingProject({
+                  ...state,
+                  step: "GitFlow",
+                  data: {
+                    ...state.data,
+                    targetBranch
+                  }
+                }));
+              }
+            case "GitFlow":
+              {
+                const gitFlow = text === "Commit" ? "commit" : "pr";
+                yield* notifier.sendMessage({
+                  text: "Enable review agent?",
+                  options: [{
+                    label: "Yes"
+                  }, {
+                    label: "No"
+                  }, {
+                    label: ABORT_BUTTON_LABEL
+                  }]
+                });
+                return reply(ChatState.CreatingProject({
+                  ...state,
+                  step: "ReviewAgent",
+                  data: {
+                    ...state.data,
+                    gitFlow
+                  }
+                }));
+              }
+            case "ReviewAgent":
+              {
+                const reviewAgent = text === "Yes";
+                const data = state.data;
+                yield* projectStore.createProject({
+                  id: data.name,
+                  targetBranch: data.targetBranch != null ? _effect.Option.some(data.targetBranch) : _effect.Option.none(),
+                  concurrency: data.concurrency,
+                  gitFlow: data.gitFlow,
+                  reviewAgent
+                }).pipe(_effect.Effect.tapError(err => notifier.sendMessage(`Failed to create project: ${err.message}`)), _effect.Effect.orElseSucceed(() => undefined));
+                yield* notifier.sendMessage(`Project <b>${data.name}</b> created.`);
+                if (state.continueWithPlan) {
+                  yield* notifier.sendMessage({
+                    text: "What type of change?",
+                    options: [...PLAN_TYPE_LABELS.map(label => ({
+                      label
+                    })), {
+                      label: ABORT_BUTTON_LABEL
+                    }]
+                  });
+                  return reply(ChatState.SelectingPlanType({
+                    projectId: data.name
+                  }));
+                }
+                yield* notifier.sendMessage({
+                  text: "Ready.",
+                  replyKeyboard: IDLE_KEYBOARD
+                });
+                return reply(ChatState.Idle());
+              }
+          }
+        }
+    }
+  }).pipe(_effect.Effect.annotateLogs("service", "PlanInput"), _effect.Effect.tapError(err => _effect.Effect.logError(`Incoming message error: ${String(err)}`)), _effect.Effect.orElseSucceed(() => reply(ctx.state)))),
+  // ── PlanTextOutput ─────────────────────────────────────
+  Machine.procedures.add()("PlanTextOutput", ctx => _effect.Effect.gen(function* () {
+    yield* _effect.Effect.forEach((0, _TelegramFormatter.splitMessage)((0, _TelegramFormatter.markdownToTelegramHtml)(ctx.request.text)), chunk => notifier.sendMessage(chunk));
+    return reply(ctx.state);
+  }).pipe(_effect.Effect.tapError(err => _effect.Effect.logError(`Plan event relay error: ${String(err)}`)), _effect.Effect.orElseSucceed(() => reply(ctx.state)))),
+  // ── PlanQuestionReceived ───────────────────────────────
+  Machine.procedures.add()("PlanQuestionReceived", ctx => _effect.Effect.gen(function* () {
+    const {
+      request,
+      state
+    } = ctx;
+    if (state._tag !== "SessionRunning") {
+      return reply(state);
+    }
+    const labels = request.questions.flatMap(q => q.options?.map(o => o.label) ?? []);
+    const newPendingLabels = new Set([...labels, MY_ANSWER_BUTTON_LABEL, BACK_BUTTON_LABEL]);
+    let lastQ = _effect.Option.none();
+    yield* _effect.Effect.forEach(request.questions, q => {
+      const formatted = (0, _TelegramFormatter.markdownToTelegramHtml)(q.question);
+      const header = q.header != null ? `<b>${(0, _TelegramFormatter.markdownToTelegramHtml)(q.header)}</b>\n` : "";
+      const baseOptions = q.options?.map(o => ({
+        label: o.label
+      })) ?? [];
+      const msg = {
+        text: `${header}${formatted}`,
+        options: [...baseOptions, {
+          label: MY_ANSWER_BUTTON_LABEL
+        }]
+      };
+      lastQ = _effect.Option.some(msg);
+      return notifier.sendMessage(msg);
+    });
+    return reply(ChatState.SessionRunning({
+      ...state,
+      pendingAnswerCount: request.questions.length,
+      pendingOptionLabels: newPendingLabels,
+      answersBuffer: [],
+      awaitingFreeTextAnswer: false,
+      lastQuestionMessage: lastQ
+    }));
+  }).pipe(_effect.Effect.tapError(err => _effect.Effect.logError(`Plan event relay error: ${String(err)}`)), _effect.Effect.orElseSucceed(() => reply(ctx.state)))),
+  // ── PlanSpecCreatedReq ─────────────────────────────────
+  Machine.procedures.add()("PlanSpecCreatedReq", ctx => _effect.Effect.gen(function* () {
+    const active = extractActiveState(ctx.state);
+    if (_effect.Option.isNone(active)) return reply(ctx.state);
+    const {
+      analysisFollowUpSent,
+      planType,
+      projectId,
+      readyFlags
+    } = active.value;
+    const sent = yield* maybeAnalysisFollowUp(planType, analysisFollowUpSent);
+    const newFlags = new ReadyFlags({
+      ...readyFlags,
+      spec: true
+    });
+    const newState = yield* checkAllReady(projectId, planType, newFlags, sent);
+    return reply(newState);
+  }).pipe(_effect.Effect.tapError(err => _effect.Effect.logError(`Plan event relay error: ${String(err)}`)), _effect.Effect.orElseSucceed(() => reply(ctx.state)))),
+  // ── PlanSpecUpdatedReq ─────────────────────────────────
+  Machine.procedures.add()("PlanSpecUpdatedReq", ctx => _effect.Effect.gen(function* () {
+    const active = extractActiveState(ctx.state);
+    if (_effect.Option.isNone(active)) return reply(ctx.state);
+    const {
+      analysisFollowUpSent,
+      planType,
+      projectId,
+      readyFlags
+    } = active.value;
+    const sent = yield* maybeAnalysisFollowUp(planType, analysisFollowUpSent);
+    const newFlags = new ReadyFlags({
+      ...readyFlags,
+      spec: true
+    });
+    const newState = yield* checkAllReady(projectId, planType, newFlags, sent);
+    return reply(newState);
+  }).pipe(_effect.Effect.tapError(err => _effect.Effect.logError(`Plan event relay error: ${String(err)}`)), _effect.Effect.orElseSucceed(() => reply(ctx.state)))),
+  // ── PlanAnalysisReadyReq ───────────────────────────────
+  Machine.procedures.add()("PlanAnalysisReadyReq", ctx => _effect.Effect.gen(function* () {
+    const active = extractActiveState(ctx.state);
+    if (_effect.Option.isNone(active)) return reply(ctx.state);
+    const {
+      analysisFollowUpSent,
+      planType,
+      projectId,
+      readyFlags
+    } = active.value;
+    const newFlags = new ReadyFlags({
+      ...readyFlags,
+      analysis: true
+    });
+    const newState = yield* checkAllReady(projectId, planType, newFlags, analysisFollowUpSent);
+    return reply(newState);
+  }).pipe(_effect.Effect.tapError(err => _effect.Effect.logError(`Plan event relay error: ${String(err)}`)), _effect.Effect.orElseSucceed(() => reply(ctx.state)))),
+  // ── PlanAwaitingInputReq ───────────────────────────────
+  Machine.procedures.add()("PlanAwaitingInputReq", ctx => _effect.Effect.gen(function* () {
+    const active = extractActiveState(ctx.state);
+    if (_effect.Option.isNone(active)) return reply(ctx.state);
+    const {
+      analysisFollowUpSent,
+      planType,
+      projectId,
+      readyFlags
+    } = active.value;
+    const newFlags = new ReadyFlags({
+      ...readyFlags,
+      idle: true
+    });
+    const newState = yield* checkAllReady(projectId, planType, newFlags, analysisFollowUpSent);
+    return reply(newState);
+  }).pipe(_effect.Effect.tapError(err => _effect.Effect.logError(`Plan event relay error: ${String(err)}`)), _effect.Effect.orElseSucceed(() => reply(ctx.state)))),
+  // ── PlanCompletedReq ───────────────────────────────────
+  Machine.procedures.add()("PlanCompletedReq", ctx => _effect.Effect.gen(function* () {
+    yield* notifier.sendMessage({
+      text: "Plan completed.",
+      replyKeyboard: IDLE_KEYBOARD
+    });
+    return reply(ChatState.Idle());
+  }).pipe(_effect.Effect.tapError(err => _effect.Effect.logError(`Plan event relay error: ${String(err)}`)), _effect.Effect.orElseSucceed(() => reply(ctx.state)))),
+  // ── PlanFailedReq ──────────────────────────────────────
+  Machine.procedures.add()("PlanFailedReq", ctx => _effect.Effect.gen(function* () {
+    yield* notifier.sendMessage({
+      text: `Plan failed: ${ctx.request.message}`,
+      replyKeyboard: IDLE_KEYBOARD
+    });
+    return reply(ChatState.Idle());
+  }).pipe(_effect.Effect.tapError(err => _effect.Effect.logError(`Plan event relay error: ${String(err)}`)), _effect.Effect.orElseSucceed(() => reply(ctx.state)))));
+}));
+//# sourceMappingURL=ChatMachine.js.map