vidpipe 1.3.16 → 1.3.17

package/dist/cli.js

@@ -7904,10 +7904,14 @@ var init_CopilotProvider = __esm({
         let response;
         let sdkError;
         try {
-          response = await this.session.sendAndWait(
-            { prompt: message },
-            this.timeoutMs
-          );
+          if (this.timeoutMs === 0) {
+            response = await this.sendAndWaitForIdle(message);
+          } else {
+            response = await this.session.sendAndWait(
+              { prompt: message },
+              this.timeoutMs
+            );
+          }
         } catch (err) {
           sdkError = err instanceof Error ? err : new Error(String(err));
           if (sdkError.message.includes("missing finish_reason")) {
@@ -7931,6 +7935,38 @@ var init_CopilotProvider = __esm({
           durationMs: Date.now() - start
         };
       }
+      /**
+       * Send a message and wait for session.idle without any timeout.
+       * Used by interactive agents (interview, chat) where tool handlers
+       * block waiting for human input — the SDK's sendAndWait() timeout
+       * would fire while the agent is legitimately waiting for the user.
+       */
+      sendAndWaitForIdle(message) {
+        return new Promise((resolve3, reject) => {
+          let lastAssistantMessage;
+          const unsubMessage = this.session.on("assistant.message", (event) => {
+            lastAssistantMessage = event;
+          });
+          const unsubIdle = this.session.on("session.idle", () => {
+            unsubMessage();
+            unsubIdle();
+            unsubError();
+            resolve3(lastAssistantMessage);
+          });
+          const unsubError = this.session.on("session.error", (event) => {
+            unsubMessage();
+            unsubIdle();
+            unsubError();
+            reject(new Error(event.data?.message ?? "Unknown session error"));
+          });
+          this.session.send({ prompt: message }).catch((err) => {
+            unsubMessage();
+            unsubIdle();
+            unsubError();
+            reject(err instanceof Error ? err : new Error(String(err)));
+          });
+        });
+      }
       on(event, handler) {
         const handlers = this.eventHandlers.get(event) ?? [];
         handlers.push(handler);
@@ -18812,6 +18848,352 @@ async function generateIdeas(options = {}) {
   }
 }
 
+// src/L4-agents/InterviewAgent.ts
+init_BaseAgent();
+
+// src/L1-infra/progress/interviewEmitter.ts
+var InterviewEmitter = class {
+  enabled = false;
+  listeners = /* @__PURE__ */ new Set();
+  /** Turn on interview event output to stderr. */
+  enable() {
+    this.enabled = true;
+  }
+  /** Turn off interview event output. */
+  disable() {
+    this.enabled = false;
+  }
+  /** Whether the emitter is currently active (stderr or listeners). */
+  isEnabled() {
+    return this.enabled || this.listeners.size > 0;
+  }
+  /** Register a programmatic listener for interview events. */
+  addListener(fn) {
+    this.listeners.add(fn);
+  }
+  /** Remove a previously registered listener. */
+  removeListener(fn) {
+    this.listeners.delete(fn);
+  }
+  /**
+   * Write an interview event as a single JSON line to stderr (if enabled)
+   * and dispatch to all registered listeners.
+   * No-op when neither stderr output nor listeners are active.
+   */
+  emit(event) {
+    if (!this.enabled && this.listeners.size === 0) return;
+    if (this.enabled) {
+      process.stderr.write(JSON.stringify(event) + "\n");
+    }
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+};
+var interviewEmitter = new InterviewEmitter();
+
+// src/L4-agents/InterviewAgent.ts
+init_configLogger();
+var SYSTEM_PROMPT8 = `You are a Socratic interview coach helping a content creator sharpen their video idea. Ask ONE short question at a time (1 sentence max).
+
+## Rules
+- Every question must be a SINGLE sentence. No multi-part questions. No preamble. No encouragement filler.
+- Build on the previous answer \u2014 reference what the user said.
+- Push on weak spots: vague audience, generic hooks, surface-level talking points.
+- If the user responds with "/end", call end_interview immediately.
+
+## Focus (pick one per question)
+- Problem clarity \u2014 what specific pain does this solve?
+- Audience \u2014 who exactly, what skill level?
+- Key takeaway \u2014 what's the ONE thing to remember?
+- Hook \u2014 would you click this? Be specific.
+- Talking points \u2014 substantive or surface-level?
+- Trend relevance \u2014 why now?
+
+## Tools
+- ask_question: EVERY question goes through this tool. Include a 1-sentence rationale and the target field.
+- update_field: When the conversation reveals a better value for a field, DIRECTLY SET the new value. For scalar fields (hook, audience, keyTakeaway, trendContext), provide the complete replacement text. For array fields (talkingPoints), provide the FULL updated list \u2014 not just the new item. Write the actual content, not a description of the change.
+- end_interview: After 5\u201310 productive questions, wrap up with a brief summary.
+- NEVER output text outside of tool calls.`;
+var InterviewAgent = class extends BaseAgent {
+  answerProvider = null;
+  transcript = [];
+  insights = {};
+  questionNumber = 0;
+  ended = false;
+  idea = null;
+  constructor(model) {
+    super("InterviewAgent", SYSTEM_PROMPT8, void 0, model);
+  }
+  getTimeoutMs() {
+    return 0;
+  }
+  resetForRetry() {
+    this.transcript = [];
+    this.insights = {};
+    this.questionNumber = 0;
+    this.ended = false;
+  }
+  getTools() {
+    return [
+      {
+        name: "ask_question",
+        description: "Ask the user a single Socratic question to explore and develop the idea. This is the primary way you communicate \u2014 every question MUST go through this tool.",
+        parameters: {
+          type: "object",
+          properties: {
+            question: {
+              type: "string",
+              description: "The question to ask the user. Must be a single, focused question."
+            },
+            rationale: {
+              type: "string",
+              description: "Why you are asking this question \u2014 what gap or opportunity it explores."
+            },
+            targetField: {
+              type: "string",
+              description: "Which idea field this question explores (e.g. hook, audience, keyTakeaway, talkingPoints, trendContext).",
+              enum: ["topic", "hook", "audience", "keyTakeaway", "talkingPoints", "platforms", "tags", "publishBy", "trendContext"]
+            }
+          },
+          required: ["question", "rationale"],
+          additionalProperties: false
+        },
+        handler: async (args) => this.handleToolCall("ask_question", args)
+      },
+      {
+        name: "update_field",
+        description: "Directly update an idea field with new content discovered during the interview. For scalar fields, provide the complete replacement text. For talkingPoints, provide the FULL updated list (all points, not just new ones).",
+        parameters: {
+          type: "object",
+          properties: {
+            field: {
+              type: "string",
+              description: "Which idea field to update.",
+              enum: ["topic", "hook", "audience", "keyTakeaway", "talkingPoints", "tags", "trendContext"]
+            },
+            value: {
+              type: "string",
+              description: "The new value for scalar fields (hook, audience, keyTakeaway, trendContext, topic)."
+            },
+            values: {
+              type: "array",
+              items: { type: "string" },
+              description: "The full updated list for array fields (talkingPoints, tags). Include ALL items, not just new ones."
+            }
+          },
+          required: ["field"],
+          additionalProperties: false
+        },
+        handler: async (args) => this.handleToolCall("update_field", args)
+      },
+      {
+        name: "end_interview",
+        description: "Signal that the interview is complete. Use when you have gathered sufficient insights (typically after 5\u201310 questions) to meaningfully improve the idea.",
+        parameters: {
+          type: "object",
+          properties: {
+            summary: {
+              type: "string",
+              description: "A summary of what was learned and how the idea has been refined."
+            }
+          },
+          required: ["summary"],
+          additionalProperties: false
+        },
+        handler: async (args) => this.handleToolCall("end_interview", args)
+      }
+    ];
+  }
+  async handleToolCall(toolName, args) {
+    switch (toolName) {
+      case "ask_question":
+        return this.handleAskQuestion(args);
+      case "update_field":
+        return this.handleUpdateField(args);
+      case "end_interview":
+        return this.handleEndInterview(args);
+      default:
+        return { error: `Unknown tool: ${toolName}` };
+    }
+  }
+  async handleAskQuestion(args) {
+    const question = String(args.question ?? "");
+    const rationale = String(args.rationale ?? "");
+    const targetField = args.targetField;
+    this.questionNumber++;
+    const context = {
+      rationale,
+      targetField,
+      questionNumber: this.questionNumber
+    };
+    interviewEmitter.emit({
+      event: "question:asked",
+      question,
+      context,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    logger_default.info(`[InterviewAgent] Q${this.questionNumber}: ${question}`);
+    return this.waitForAnswer(question, context);
+  }
+  handleUpdateField(args) {
+    const field = String(args.field ?? "");
+    if (field === "talkingPoints" || field === "tags") {
+      const values = args.values;
+      if (values && values.length > 0) {
+        this.insights[field] = values;
+      }
+    } else {
+      const value = String(args.value ?? "");
+      if (value) {
+        this.insights[field] = value;
+      }
+    }
+    const displayValue = field === "talkingPoints" || field === "tags" ? `[${(args.values ?? []).length} items]` : String(args.value ?? "").slice(0, 60);
+    interviewEmitter.emit({
+      event: "insight:discovered",
+      insight: displayValue,
+      field,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    logger_default.info(`[InterviewAgent] Updated [${field}]: ${displayValue}`);
+    return { updated: true, field };
+  }
+  handleEndInterview(args) {
+    const summary = String(args.summary ?? "");
+    this.ended = true;
+    logger_default.info(`[InterviewAgent] Interview ended: ${summary}`);
+    return { ended: true, summary };
+  }
+  async waitForAnswer(question, context) {
+    if (!this.answerProvider) {
+      throw new Error("No answer provider configured \u2014 cannot ask questions");
+    }
+    const askedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const answer = await this.answerProvider(question, context);
+    const answeredAt = (/* @__PURE__ */ new Date()).toISOString();
+    const pair = {
+      question,
+      answer,
+      askedAt,
+      answeredAt,
+      questionNumber: context.questionNumber
+    };
+    this.transcript.push(pair);
+    interviewEmitter.emit({
+      event: "answer:received",
+      questionNumber: context.questionNumber,
+      answer,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return answer;
+  }
+  /**
+   * Run a Socratic interview session for the given idea.
+   *
+   * The agent uses `ask_question` tool calls to present questions one at a time.
+   * Each question is routed through the `answerProvider` callback, which the caller
+   * implements to show the question to the user and collect their response.
+   */
+  async runInterview(idea, answerProvider) {
+    this.idea = idea;
+    this.answerProvider = answerProvider;
+    this.transcript = [];
+    this.insights = {};
+    this.questionNumber = 0;
+    this.ended = false;
+    const startTime = Date.now();
+    interviewEmitter.emit({
+      event: "interview:start",
+      ideaNumber: idea.issueNumber,
+      mode: "interview",
+      ideaTopic: idea.topic,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const contextMessage = this.buildIdeaContext(idea);
+    try {
+      await this.run(contextMessage);
+      const result = {
+        ideaNumber: idea.issueNumber,
+        transcript: this.transcript,
+        insights: this.insights,
+        updatedFields: this.getUpdatedFields(),
+        durationMs: Date.now() - startTime,
+        endedBy: this.ended ? "agent" : "user"
+      };
+      interviewEmitter.emit({
+        event: "interview:complete",
+        result,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return result;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      interviewEmitter.emit({
+        event: "interview:error",
+        error: message,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      throw error;
+    }
+  }
+  buildIdeaContext(idea) {
+    const talkingPoints = idea.talkingPoints.length > 0 ? idea.talkingPoints.map((p) => `- ${p}`).join("\n") : "- (none yet)";
+    return [
+      "Here is the idea to explore through Socratic questioning:",
+      "",
+      `**Topic:** ${idea.topic}`,
+      `**Hook:** ${idea.hook}`,
+      `**Audience:** ${idea.audience}`,
+      `**Key Takeaway:** ${idea.keyTakeaway}`,
+      "**Talking Points:**",
+      talkingPoints,
+      `**Publish By:** ${idea.publishBy}`,
+      `**Trend Context:** ${idea.trendContext ?? "Not specified"}`,
+      "",
+      "Begin by asking your first Socratic question to explore and develop this idea."
+    ].join("\n");
+  }
+  getUpdatedFields() {
+    const fields = [];
+    if (this.insights.talkingPoints !== void 0) fields.push("talkingPoints");
+    if (this.insights.keyTakeaway !== void 0) fields.push("keyTakeaway");
+    if (this.insights.hook !== void 0) fields.push("hook");
+    if (this.insights.audience !== void 0) fields.push("audience");
+    if (this.insights.trendContext !== void 0) fields.push("trendContext");
+    if (this.insights.tags !== void 0) fields.push("tags");
+    return fields;
+  }
+  setupEventHandlers(session) {
+    session.on("delta", () => {
+    });
+    session.on("tool_start", (event) => {
+      const toolName = event.data?.name ?? "unknown";
+      if (toolName !== "ask_question") {
+        interviewEmitter.emit({
+          event: "tool:start",
+          toolName,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    });
+    session.on("tool_end", (event) => {
+      const toolName = event.data?.name ?? "unknown";
+      if (toolName !== "ask_question") {
+        interviewEmitter.emit({
+          event: "tool:end",
+          toolName,
+          durationMs: 0,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    });
+    session.on("error", (event) => {
+      logger_default.error(`[InterviewAgent] error: ${JSON.stringify(event.data)}`);
+    });
+  }
+};
+
 // src/L5-assets/pipelineServices.ts
 var costTracker3 = {
   reset: (...args) => costTracker2.reset(...args),
@@ -18835,6 +19217,9 @@ function markFailed3(...args) {
 function generateIdeas2(...args) {
   return generateIdeas(...args);
 }
+function createInterviewAgent(...args) {
+  return new InterviewAgent(...args);
+}
 function createScheduleAgent(...args) {
   return new ScheduleAgent(...args);
 }
@@ -19789,15 +20174,225 @@ async function runRealign(options = {}) {
 init_environment();
 init_configLogger();
 
-// src/L1-infra/readline/readline.ts
-import { createInterface } from "readline";
-function createChatInterface(options) {
-  return createInterface({
-    input: options?.input ?? process.stdin,
-    output: options?.output ?? process.stdout,
-    terminal: false
+// src/L1-infra/terminal/altScreenChat.tsx
+import { useState, useCallback, useEffect } from "react";
+import { render, Box, Text, useInput, useApp, useStdout } from "ink";
+import TextInput from "ink-text-input";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function Header({ title, subtitle }) {
+  const { stdout } = useStdout();
+  const cols = stdout?.columns ?? 80;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: cols, children: [
+    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { backgroundColor: "blue", color: "white", bold: true, children: `  \u{1F4DD} ${title}`.padEnd(cols) }) }),
+    /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { backgroundColor: "blue", color: "white", dimColor: true, children: `  ${subtitle}`.padEnd(cols) }) }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2500".repeat(cols) })
+  ] });
+}
+var FIELD_EMOJI = {
+  topic: "\u{1F4CC} topic",
+  hook: "\u{1FA9D} hook",
+  audience: "\u{1F3AF} audience",
+  keyTakeaway: "\u{1F48E} takeaway",
+  talkingPoints: "\u{1F4CB} talking points",
+  platforms: "\u{1F4F1} platforms",
+  tags: "\u{1F3F7}\uFE0F tags",
+  publishBy: "\u{1F4C5} deadline",
+  trendContext: "\u{1F525} trend"
+};
+function QuestionCardView({ card, latestInsight, statusText }) {
+  if (!card) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", flexGrow: 1, justifyContent: "center", alignItems: "center", children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: statusText || "Preparing first question..." }) });
+  }
+  const fieldLabel = FIELD_EMOJI[card.targetField] ?? `\u{1F4CE} ${card.targetField}`;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", flexGrow: 1, paddingLeft: 2, paddingRight: 2, children: [
+    /* @__PURE__ */ jsx(Text, { children: " " }),
+    /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "Question ",
+        card.questionNumber
+      ] }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: fieldLabel })
+    ] }),
+    /* @__PURE__ */ jsx(Text, { children: " " }),
+    /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, wrap: "wrap", children: card.question }),
+    /* @__PURE__ */ jsx(Text, { children: " " }),
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u{1F4AD} " }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, wrap: "wrap", children: card.rationale })
+    ] }),
+    latestInsight && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Text, { color: "yellow", children: "\u{1F4A1} " }),
+        /* @__PURE__ */ jsx(Text, { color: "yellow", wrap: "wrap", children: latestInsight })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Text, { children: " " }),
+    statusText && /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: statusText }) })
+  ] });
+}
+function InputLine({ prompt, value, onChange, onSubmit, active }) {
+  const { stdout } = useStdout();
+  const cols = stdout?.columns ?? 80;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2500".repeat(cols) }),
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: prompt }),
+      active ? /* @__PURE__ */ jsx(TextInput, { value, onChange, onSubmit }) : /* @__PURE__ */ jsx(Text, { dimColor: true, children: " waiting..." })
+    ] })
+  ] });
+}
+function ChatApp({ controller }) {
+  const { exit } = useApp();
+  const [card, setCard] = useState(null);
+  const [latestInsight, setLatestInsight] = useState(null);
+  const [statusText, setStatusText] = useState("");
+  const [inputValue, setInputValue] = useState("");
+  const [inputActive, setInputActive] = useState(false);
+  const [, setTick] = useState(0);
+  useEffect(() => {
+    controller._wire({
+      setCard,
+      setLatestInsight,
+      setStatusText,
+      setInputActive,
+      exit,
+      forceRender: () => setTick((t) => t + 1)
+    });
+    return () => controller._unwire();
+  }, [controller, exit]);
+  useInput((_input, key) => {
+    if (key.ctrl && _input === "c") {
+      controller.interrupted = true;
+      const resolve3 = controller._pendingResolve;
+      controller._pendingResolve = null;
+      if (resolve3) resolve3("");
+      exit();
+    }
   });
-}
+  const handleSubmit = useCallback((value) => {
+    setInputValue("");
+    setInputActive(false);
+    const resolve3 = controller._pendingResolve;
+    controller._pendingResolve = null;
+    if (resolve3) resolve3(value.trim());
+  }, [controller]);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", height: "100%", children: [
+    /* @__PURE__ */ jsx(
+      Header,
+      {
+        title: controller.title,
+        subtitle: controller.subtitle
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      QuestionCardView,
+      {
+        card,
+        latestInsight,
+        statusText
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      InputLine,
+      {
+        prompt: controller.inputPrompt,
+        value: inputValue,
+        onChange: setInputValue,
+        onSubmit: handleSubmit,
+        active: inputActive
+      }
+    )
+  ] });
+}
+var AltScreenChat = class {
+  title;
+  subtitle;
+  inputPrompt;
+  maxScrollback;
+  messages = [];
+  bridge = null;
+  inkInstance = null;
+  /** Set to true when Ctrl+C is pressed. Callers should check this after promptInput(). */
+  interrupted = false;
+  /** @internal */
+  _pendingResolve = null;
+  constructor(options) {
+    this.title = options.title;
+    this.subtitle = options.subtitle ?? "Type /end to finish, Ctrl+C to quit";
+    this.inputPrompt = options.inputPrompt ?? "> ";
+    this.maxScrollback = options.maxScrollback ?? 500;
+  }
+  /** @internal */
+  _wire(bridge) {
+    this.bridge = bridge;
+  }
+  /** @internal */
+  _unwire() {
+    this.bridge = null;
+  }
+  /** Enter fullscreen and render the Ink UI. */
+  enter() {
+    this.inkInstance = render(
+      /* @__PURE__ */ jsx(ChatApp, { controller: this }),
+      { exitOnCtrlC: false }
+    );
+  }
+  /** Leave fullscreen and clean up Ink. */
+  leave() {
+    if (this.inkInstance) {
+      this.inkInstance.unmount();
+      this.inkInstance = null;
+    }
+  }
+  /** Clean up everything. */
+  destroy() {
+    this.leave();
+    this.messages = [];
+    this.bridge = null;
+    this._pendingResolve = null;
+  }
+  /**
+   * Show a focused question card. Replaces the entire display content
+   * with this one question — no scrolling chat history.
+   */
+  showQuestion(question, rationale, targetField, questionNumber) {
+    this.bridge?.setCard({ question, rationale, targetField, questionNumber });
+  }
+  /**
+   * Show a discovered insight on the current card.
+   */
+  showInsight(text) {
+    this.bridge?.setLatestInsight(text);
+  }
+  /**
+   * Add a message to the internal log (for transcript purposes).
+   * Does NOT affect the card display — use showQuestion for that.
+   */
+  addMessage(role, content) {
+    const msg = { role, content, timestamp: /* @__PURE__ */ new Date() };
+    this.messages.push(msg);
+    if (this.messages.length > this.maxScrollback) {
+      this.messages = this.messages.slice(-this.maxScrollback);
+    }
+  }
+  /** Set the status bar text. */
+  setStatus(text) {
+    this.bridge?.setStatusText(text);
+  }
+  /** Clear the status bar. */
+  clearStatus() {
+    this.bridge?.setStatusText("");
+  }
+  /** Prompt for user input. Returns their trimmed text. */
+  promptInput(_prompt) {
+    return new Promise((resolve3) => {
+      this._pendingResolve = resolve3;
+      this.bridge?.setInputActive(true);
+      this.bridge?.forceRender();
+    });
+  }
+};
 
 // src/L6-pipeline/scheduleChat.ts
 function createScheduleAgent2(...args) {
@@ -19808,21 +20403,21 @@ function createScheduleAgent2(...args) {
 async function runChat() {
   initConfig();
   setChatMode(true);
-  const rl2 = createChatInterface();
+  const chat = new AltScreenChat({
+    title: "\u{1F4AC} VidPipe Chat",
+    subtitle: "Schedule management assistant. Type exit or quit to leave.",
+    inputPrompt: "vidpipe> "
+  });
   const handleUserInput = (request) => {
+    chat.addMessage("agent", request.question);
+    if (request.choices && request.choices.length > 0) {
+      const choiceText = request.choices.map((c, i) => `  ${i + 1}. ${c}`).join("\n");
+      chat.addMessage("system", choiceText + (request.allowFreeform !== false ? "\n  (or type a custom answer)" : ""));
+    }
     return new Promise((resolve3) => {
-      console.log();
-      console.log(`\x1B[33m\u{1F916} Agent asks:\x1B[0m ${request.question}`);
-      if (request.choices && request.choices.length > 0) {
-        for (let i = 0; i < request.choices.length; i++) {
-          console.log(`  ${i + 1}. ${request.choices[i]}`);
-        }
-        if (request.allowFreeform !== false) {
-          console.log(`  (or type a custom answer)`);
-        }
-      }
-      rl2.question("\x1B[33m> \x1B[0m", (answer) => {
+      chat.promptInput("> ").then((answer) => {
         const trimmed = answer.trim();
+        chat.addMessage("user", trimmed);
         if (request.choices && request.choices.length > 0) {
           const num = parseInt(trimmed, 10);
           if (num >= 1 && num <= request.choices.length) {
@@ -19836,61 +20431,36 @@ async function runChat() {
   };
   const agent = createScheduleAgent2(handleUserInput);
   agent.setChatOutput((message) => {
-    process.stderr.write(`${message}
-`);
-  });
-  console.log(`
-\x1B[36m\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
-\u2551   VidPipe Chat                       \u2551
-\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D\x1B[0m
-
-Schedule management assistant. Ask me about your posting schedule,
-reschedule posts, check what's coming up, or reprioritize content.
-
-Type \x1B[33mexit\x1B[0m or \x1B[33mquit\x1B[0m to leave. Press Ctrl+C to stop.
-`);
-  let closeRejector = null;
-  const closePromise = new Promise((_, reject) => {
-    closeRejector = reject;
-    rl2.once("close", () => reject(new Error("readline closed")));
+    chat.setStatus(message);
   });
-  const prompt = () => {
-    return Promise.race([
-      new Promise((resolve3) => {
-        rl2.question("\x1B[32mvidpipe>\x1B[0m ", (answer) => {
-          resolve3(answer);
-        });
-      }),
-      closePromise
-    ]);
-  };
+  chat.enter();
+  chat.addMessage("system", "Ask me about your posting schedule, reschedule posts, check what's coming up, or reprioritize content.");
   try {
     while (true) {
-      let input;
-      try {
-        input = await prompt();
-      } catch {
-        break;
-      }
+      const input = await chat.promptInput();
       const trimmed = input.trim();
       if (!trimmed) continue;
       if (trimmed === "exit" || trimmed === "quit") {
-        console.log("\nGoodbye! \u{1F44B}");
+        chat.addMessage("system", "Goodbye! \u{1F44B}");
         break;
       }
+      chat.addMessage("user", trimmed);
+      chat.setStatus("\u{1F914} Thinking...");
       try {
-        await agent.run(trimmed);
-        console.log("\n");
+        const response = await agent.run(trimmed);
+        chat.clearStatus();
+        if (response) {
+          chat.addMessage("agent", response);
+        }
       } catch (err) {
+        chat.clearStatus();
         const message = err instanceof Error ? err.message : String(err);
-        console.error(`
-\x1B[31mError: ${message}\x1B[0m
-`);
+        chat.addMessage("error", message);
       }
     }
   } finally {
     await agent.destroy();
-    rl2.close();
+    chat.destroy();
     setChatMode(false);
   }
 }
@@ -19903,6 +20473,16 @@ init_ideaService();
 function generateIdeas3(...args) {
   return generateIdeas2(...args);
 }
+async function startInterview(idea, answerProvider, onEvent) {
+  if (onEvent) interviewEmitter.addListener(onEvent);
+  const agent = createInterviewAgent();
+  try {
+    return await agent.runInterview(idea, answerProvider);
+  } finally {
+    await agent.destroy();
+    if (onEvent) interviewEmitter.removeListener(onEvent);
+  }
+}
 
 // src/L7-app/commands/ideate.ts
 init_types();
@@ -20072,10 +20652,200 @@ async function handleAdd(options) {
   }
 }
 
+// src/L7-app/commands/ideateStart.ts
+init_environment();
+init_configLogger();
+
+// src/L3-services/interview/interviewService.ts
+init_configLogger();
+init_githubClient();
+init_ideaService();
+async function loadAndValidateIdea(issueNumber) {
+  const idea = await getIdea(issueNumber);
+  if (!idea) {
+    throw new Error(`Idea #${issueNumber} not found`);
+  }
+  if (idea.status !== "draft") {
+    throw new Error(
+      `Idea #${issueNumber} has status "${idea.status}" \u2014 only draft ideas can be started`
+    );
+  }
+  return idea;
+}
+function formatTranscriptComment(transcript) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const date = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+  const lines = [
+    "<!-- vidpipe:idea-comment -->",
+    `<!-- {"type":"interview-transcript","savedAt":"${now}"} -->`,
+    "",
+    "## \u{1F399}\uFE0F Interview Transcript",
+    "",
+    `**Questions asked:** ${transcript.length}`,
+    `**Date:** ${date}`,
+    "",
+    "---"
+  ];
+  for (const qa of transcript) {
+    lines.push("");
+    lines.push(`### Q${qa.questionNumber}: ${qa.question}`);
+    lines.push(`> ${qa.answer}`);
+  }
+  return lines.join("\n");
+}
+async function saveTranscript(issueNumber, transcript) {
+  const body = formatTranscriptComment(transcript);
+  const client = getGitHubClient();
+  await client.addComment(issueNumber, body);
+  logger_default.info(`Saved interview transcript (${transcript.length} Q&A) to issue #${issueNumber}`);
+}
+async function updateIdeaFromInsights(issueNumber, insights) {
+  const updates = {};
+  const updatedFields = [];
+  if (insights.hook !== void 0) {
+    updates.hook = insights.hook;
+    updatedFields.push("hook");
+  }
+  if (insights.audience !== void 0) {
+    updates.audience = insights.audience;
+    updatedFields.push("audience");
+  }
+  if (insights.keyTakeaway !== void 0) {
+    updates.keyTakeaway = insights.keyTakeaway;
+    updatedFields.push("keyTakeaway");
+  }
+  if (insights.trendContext !== void 0) {
+    updates.trendContext = insights.trendContext;
+    updatedFields.push("trendContext");
+  }
+  if (insights.talkingPoints !== void 0 && insights.talkingPoints.length > 0) {
+    updates.talkingPoints = insights.talkingPoints;
+    updatedFields.push("talkingPoints");
+  }
+  if (insights.tags !== void 0 && insights.tags.length > 0) {
+    updates.tags = insights.tags;
+    updatedFields.push("tags");
+  }
+  if (updatedFields.length === 0) {
+    logger_default.info(`No fields to update for idea #${issueNumber} from insights`);
+    return;
+  }
+  await updateIdea(issueNumber, updates);
+  logger_default.info(
+    `Updated idea #${issueNumber} fields: ${updatedFields.join(", ")}`
+  );
+}
+
+// src/L7-app/commands/ideateStart.ts
+init_ideaService();
+var VALID_MODES = ["interview"];
+async function runIdeateStart(issueNumber, options) {
+  const parsed = Number.parseInt(issueNumber, 10);
+  if (Number.isNaN(parsed) || parsed < 1) {
+    console.error(`Invalid issue number: "${issueNumber}". Must be a positive integer.`);
+    process.exit(1);
+  }
+  initConfig();
+  const mode = options.mode ?? "interview";
+  if (!VALID_MODES.includes(mode)) {
+    console.error(`Unknown mode: "${options.mode}". Valid modes: ${VALID_MODES.join(", ")}`);
+    process.exit(1);
+  }
+  if (options.progress) {
+    interviewEmitter.enable();
+  }
+  const idea = await loadAndValidateIdea(parsed);
+  const chat = new AltScreenChat({
+    title: `\u{1F4DD} Interview: ${idea.topic}`,
+    subtitle: "Type /end to finish the interview. Press Ctrl+C to save and quit.",
+    inputPrompt: "Your answer> "
+  });
+  const answerProvider = async (question, context) => {
+    chat.showQuestion(
+      question,
+      context.rationale,
+      context.targetField ? String(context.targetField) : "general",
+      context.questionNumber
+    );
+    const answer = await chat.promptInput();
+    if (chat.interrupted) {
+      return "/end";
+    }
+    chat.addMessage("agent", question);
+    chat.addMessage("user", answer);
+    return answer;
+  };
+  const handleEvent = (event) => {
+    switch (event.event) {
+      case "thinking:start":
+        chat.setStatus("\u{1F914} Thinking of next question...");
+        break;
+      case "thinking:end":
+        chat.clearStatus();
+        break;
+      case "tool:start":
+        chat.setStatus(`\u{1F527} ${event.toolName}...`);
+        break;
+      case "tool:end":
+        chat.clearStatus();
+        break;
+      case "insight:discovered":
+        chat.showInsight(`${event.field}: ${event.insight}`);
+        break;
+    }
+  };
+  setChatMode(true);
+  chat.enter();
+  chat.addMessage("system", `Starting interview for idea #${idea.issueNumber}: ${idea.topic}`);
+  chat.addMessage("system", "The agent will ask Socratic questions to help develop your idea.");
+  try {
+    const result = await startInterview(idea, answerProvider, handleEvent);
+    await saveResults(result, chat, parsed);
+  } catch (error) {
+    if (error instanceof Error) {
+      chat.addMessage("error", error.message);
+    }
+    throw error;
+  } finally {
+    chat.destroy();
+    setChatMode(false);
+  }
+}
+async function saveResults(result, chat, issueNumber) {
+  const durationSec = Math.round(result.durationMs / 1e3);
+  const fieldList = result.updatedFields.length > 0 ? result.updatedFields.join(", ") : "none";
+  chat.showQuestion(
+    `Interview ${result.endedBy === "user" ? "ended" : "completed"} \u2014 ${result.transcript.length} questions in ${durationSec}s`,
+    `Updated fields: ${fieldList}`,
+    "summary",
+    result.transcript.length
+  );
+  if (result.transcript.length > 0) {
+    chat.setStatus("\u{1F4BE} Saving transcript...");
+    await saveTranscript(issueNumber, result.transcript);
+  }
+  if (result.insights && Object.keys(result.insights).length > 0) {
+    chat.setStatus("\u{1F4BE} Updating idea fields...");
+    await updateIdeaFromInsights(issueNumber, result.insights);
+  }
+  chat.clearStatus();
+  chat.showInsight("\u2705 Saved! Mark this idea as ready? (yes/no)");
+  const response = await chat.promptInput();
+  if (response.toLowerCase().startsWith("y")) {
+    await updateIdea(issueNumber, { status: "ready" });
+    chat.showInsight(`\u2705 Idea #${issueNumber} marked as ready`);
+    await new Promise((resolve3) => setTimeout(resolve3, 1500));
+  }
+}
+
 // src/L1-infra/readline/readlinePromises.ts
-import { createInterface as createInterface2 } from "readline/promises";
+import { createInterface } from "readline/promises";
 function createPromptInterface(options) {
-  return createInterface2({
+  return createInterface({
     input: options?.input ?? process.stdin,
     output: options?.output ?? process.stdout
   });
@@ -21743,6 +22513,10 @@ program.command("chat").description("Interactive chat session with the schedule
 program.command("doctor").description("Check all prerequisites and dependencies").action(async () => {
   await runDoctor();
 });
+program.command("ideate-start <issue-number>").description("Start an interactive session to develop a content idea").option("--mode <mode>", "Session mode: interview (default)", "interview").option("--progress", "Emit structured JSON interview events to stderr").action(async (issueNumber, opts) => {
+  await runIdeateStart(issueNumber, opts);
+  process.exit(0);
+});
 program.command("ideate").description("Generate AI-powered content ideas using trend research").option("--topics <topics>", "Comma-separated seed topics").option("--count <n>", "Number of ideas to generate (default: 5)", "5").option("--output <dir>", "Ideas directory (default: ./ideas)").option("--brand <path>", "Brand config path (default: ./brand.json)").option("--list", "List existing ideas instead of generating").option("--status <status>", "Filter by status when listing (draft|ready|recorded|published)").option("--format <format>", "Output format: table (default) or json").option("--add", "Add a single idea (AI-researched by default, or --no-ai for direct)").option("--topic <topic>", "Idea topic/title (required with --add)").option("--hook <hook>", "Attention-grabbing hook (default: topic, --no-ai only)").option("--audience <audience>", "Target audience (default: developers, --no-ai only)").option("--platforms <platforms>", "Comma-separated platforms: tiktok,youtube,instagram,linkedin,x (--no-ai only)").option("--key-takeaway <takeaway>", "Core message the viewer should remember (--no-ai only)").option("--talking-points <points>", "Comma-separated talking points (--no-ai only)").option("--tags <tags>", "Comma-separated categorization tags (--no-ai only)").option("--publish-by <date>", "Publish deadline (ISO 8601 date, default: 14 days from now, --no-ai only)").option("--trend-context <context>", "Why this topic is timely (--no-ai only)").option("--no-ai", "Skip AI research agent \u2014 create directly from CLI flags + defaults").option("-p, --prompt <prompt>", 'Free-form prompt to guide idea generation (e.g., "Cover this article: https://...")').action(async (opts) => {
   initConfig();
   await runIdeate(opts);