ralphctl 0.3.0 → 0.4.0

package/dist/{add-JGUOR4Z5.mjs → add-CIM72NE3.mjs}

@@ -2,9 +2,9 @@
 import {
   addSingleTicketInteractive,
   ticketAddCommand
-} from "./chunk-JXMHLW42.mjs";
+} from "./chunk-7JLZQICD.mjs";
 import "./chunk-NUYQK5MN.mjs";
-import "./chunk-HL4ZMHCQ.mjs";
+import "./chunk-JOQO4HMM.mjs";
 import "./chunk-CFUVE2BP.mjs";
 import "./chunk-747KW2RW.mjs";
 import "./chunk-YCDUVPRT.mjs";

package/dist/{chunk-JXMHLW42.mjs → chunk-7JLZQICD.mjs}

@@ -4,8 +4,9 @@ import {
 } from "./chunk-NUYQK5MN.mjs";
 import {
   addTicket,
-  fetchIssueFromUrl
-} from "./chunk-HL4ZMHCQ.mjs";
+  fetchIssueFromUrl,
+  truncate
+} from "./chunk-JOQO4HMM.mjs";
 import {
   EXIT_ERROR,
   exitWithCode
@@ -82,7 +83,7 @@ function tryFetchIssue(url) {
   }
   spinner.succeed("Issue data fetched");
   log.newline();
-  const bodyPreview = data.body.length > 200 ? data.body.slice(0, 200) + "..." : data.body;
+  const bodyPreview = truncate(data.body, 200);
   const cardLines = [`Title: ${data.title}`, "", bodyPreview];
   if (data.comments.length > 0) {
     cardLines.push("", `${String(data.comments.length)} comment(s)`);

package/dist/{chunk-HL4ZMHCQ.mjs → chunk-JOQO4HMM.mjs}

@@ -99,6 +99,13 @@ function formatTicketDisplay(ticket) {
   return `[${ticket.id}] ${ticket.title}`;
 }
 
+// src/domain/strings.ts
+function truncate(str, max) {
+  if (str.length <= max) return str;
+  if (max <= 1) return "\u2026".slice(0, Math.max(0, max));
+  return str.slice(0, max - 1) + "\u2026";
+}
+
 // src/integration/external/issue-fetch.ts
 import { spawnSync } from "child_process";
 import { Result } from "typescript-result";
@@ -256,6 +263,7 @@ export {
   allRequirementsApproved,
   getPendingRequirements,
   formatTicketDisplay,
+  truncate,
   fetchIssueFromUrl,
   formatIssueContext
 };

package/dist/{chunk-CDOPLXFK.mjs → chunk-JYCGQA2D.mjs}

@@ -2,8 +2,9 @@
 import {
   fetchIssueFromUrl,
   formatIssueContext,
-  formatTicketDisplay
-} from "./chunk-HL4ZMHCQ.mjs";
+  formatTicketDisplay,
+  truncate
+} from "./chunk-JOQO4HMM.mjs";
 import {
   EXIT_ERROR,
   EXIT_INTERRUPTED,
@@ -691,10 +692,11 @@ var RefineTicketRequirementsUseCase = class {
       return "skipped";
     }
     const combined = this.combineRequirements(matching);
-    this.logger.info(`Refined requirements:
-${combined.requirements}`);
-    const approve = await this.ui.confirm("Approve these requirements?", true);
+    const approve = await this.ui.confirm("Approve these requirements?", true, combined.requirements);
     if (!approve) {
+      this.logger.warning(
+        `Requirements rejected for ticket [${ticket.id}]. Re-run \`sprint refine\` to start fresh (resume is not yet supported).`
+      );
       return "skipped";
     }
     const ticketIdx = sprint.tickets.findIndex((t) => t.id === ticket.id);
@@ -1856,32 +1858,56 @@ ${instructions}`;
    * `feedback-loop` step after execution completes with all tasks done and
    * the user hasn't opted out via `--no-feedback` / `--session`.
    *
+   * Each iteration reads multi-line markdown feedback via the editor prompt
+   * and, for each affected repo, runs a *synthetic task* — a `Task` built
+   * in-memory (never persisted to `tasks.json`) that reuses the same
+   * building blocks as `executeOneTask`:
+   *
+   *   - `task-started` / `task-finished` emissions to the signal bus keep
+   *     the live dashboard ticking.
+   *   - `dispatchSignals` routes parsed progress / note / blocked signals
+   *     to the durable signal handler so entries land in `progress.md`.
+   *   - `runPostTaskCheck` gates each iteration through the same check
+   *     script used for real tasks.
+   *
    * The hard cap `MAX_FEEDBACK_ITERATIONS` lives inside this method so the
    * calling step stays a thin adapter.
    */
   async runFeedbackLoopOnly(sprint, options) {
     const MAX_FEEDBACK_ITERATIONS = 10;
-    for (let iteration = 0; iteration < MAX_FEEDBACK_ITERATIONS; iteration++) {
+    const tasks = await this.persistence.getTasks(sprint.id);
+    const repoIds = [...new Set(tasks.map((t) => t.repoId))];
+    const repoPathByRepoId = /* @__PURE__ */ new Map();
+    for (const repoId of repoIds) {
+      try {
+        repoPathByRepoId.set(repoId, await this.persistence.resolveRepoPath(repoId));
+      } catch {
+      }
+    }
+    const completedSummary = tasks.filter((t) => t.status === "done").map((t) => `- ${t.name} (${repoPathByRepoId.get(t.repoId) ?? t.repoId})`).join("\n");
+    let iteration = 0;
+    for (; iteration < MAX_FEEDBACK_ITERATIONS; iteration++) {
       const feedback = await this.ui.getFeedback("All tasks complete. Enter feedback for changes (empty to approve):");
       if (!feedback) return;
       await this.persistence.logProgress(`User feedback: ${feedback}`, { sprintId: sprint.id });
-      const tasks = await this.persistence.getTasks(sprint.id);
-      const repoIds = [...new Set(tasks.map((t) => t.repoId))];
-      const repoPathByRepoId = /* @__PURE__ */ new Map();
-      for (const repoId of repoIds) {
-        try {
-          repoPathByRepoId.set(repoId, await this.persistence.resolveRepoPath(repoId));
-        } catch {
-        }
-      }
-      const completedSummary = tasks.filter((t) => t.status === "done").map((t) => `- ${t.name} (${repoPathByRepoId.get(t.repoId) ?? t.repoId})`).join("\n");
       for (const repoId of repoIds) {
         const repoPath = repoPathByRepoId.get(repoId);
         if (!repoPath) continue;
+        const syntheticTask = this.makeFeedbackTask(feedback, repoId);
+        this.signalBus.emit({
+          type: "task-started",
+          sprintId: sprint.id,
+          taskId: syntheticTask.id,
+          taskName: syntheticTask.name,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+        let finishStatus = "done";
         const prompt = this.promptBuilder.buildFeedbackPrompt(sprint.name, completedSummary, feedback, sprint.branch);
-        this.logger.info(`Implementing feedback in ${repoPath}...`);
-        const spinner = this.logger.spinner("AI is implementing feedback...");
+        const spinner = this.logger.spinner(
+          `${this.aiSession.getProviderDisplayName()} is working on: ${syntheticTask.name}`
+        );
         try {
+          await this.aiSession.ensureReady();
           const sprintDir = this.fs.getSprintDir(sprint.id);
           const result = await this.aiSession.spawnWithRetry(prompt, {
             cwd: repoPath,
@@ -1889,32 +1915,64 @@ ${instructions}`;
             env: this.aiSession.getSpawnEnv(),
             maxTurns: options?.maxTurns
           });
-          spinner.succeed("Feedback implementation completed");
-          const signals = this.parser.parseExecutionSignals(result.output);
-          if (signals.blocked) {
-            this.logger.warning(`Feedback blocked: ${signals.blocked}`);
+          spinner.succeed(`${this.aiSession.getProviderDisplayName()} completed: ${syntheticTask.name}`);
+          const ctx = { sprintId: sprint.id, taskId: syntheticTask.id, projectPath: repoPath };
+          const signals = await this.dispatchSignals(result.output, ctx);
+          const blocked = signals.find((s) => s.type === "task-blocked");
+          if (blocked) {
+            finishStatus = "blocked";
+            this.logger.warning(`Feedback blocked in ${repoPath}: ${blocked.reason}`);
           }
         } catch (err) {
-          spinner.fail("Feedback implementation failed");
+          spinner.fail(`${this.aiSession.getProviderDisplayName()} failed: ${syntheticTask.name}`);
+          finishStatus = "failed";
           this.logger.warning(err instanceof Error ? err.message : String(err));
         }
-      }
-      for (const repoId of repoIds) {
-        const resolved = await findProjectForRepoId(this.persistence, repoId);
-        const checkScript = resolveCheckScriptForRepo(resolved?.repo);
-        if (resolved && checkScript) {
-          const { repo } = resolved;
-          this.logger.info(`Running checks after feedback: ${checkScript}`);
-          const result = this.external.runCheckScript(repo.path, checkScript, "taskComplete", repo.checkTimeout);
-          if (!result.passed) {
-            this.logger.warning(`Check failed after feedback in ${repo.path}`);
-          } else {
-            this.logger.success(`Checks passed: ${repo.path}`);
+        try {
+          const passed = await this.runPostTaskCheck(syntheticTask, sprint);
+          if (!passed) {
+            this.logger.warning(`Post-feedback check failed in ${repoPath}`);
+            if (finishStatus === "done") finishStatus = "failed";
           }
+        } catch (err) {
+          this.logger.warning(
+            `Post-feedback check error in ${repoPath}: ${err instanceof Error ? err.message : String(err)}`
+          );
+          if (finishStatus === "done") finishStatus = "failed";
         }
+        this.signalBus.emit({
+          type: "task-finished",
+          sprintId: sprint.id,
+          taskId: syntheticTask.id,
+          status: finishStatus,
+          timestamp: /* @__PURE__ */ new Date()
+        });
       }
     }
-    this.logger.warning(`Reached maximum feedback iterations (${String(MAX_FEEDBACK_ITERATIONS)}). Proceeding.`);
+    if (iteration >= MAX_FEEDBACK_ITERATIONS) {
+      this.logger.warning(`Reached maximum feedback iterations (${String(MAX_FEEDBACK_ITERATIONS)}). Proceeding.`);
+    }
+  }
+  /**
+   * Build an in-memory `Task` representing a single feedback iteration for a
+   * single repo. Never persisted — used only to drive the shared building
+   * blocks (`runPostTaskCheck`, signal dispatch, bus lifecycle) without
+   * polluting `tasks.json`.
+   */
+  makeFeedbackTask(feedback, repoId) {
+    return {
+      id: `feedback-${generateUuid8()}`,
+      name: `Feedback: ${truncate(feedback, 60)}`,
+      description: feedback,
+      steps: [feedback],
+      verificationCriteria: ["Project check script passes"],
+      status: "todo",
+      order: 0,
+      blockedBy: [],
+      repoId,
+      verified: false,
+      evaluated: false
+    };
   }
   // -------------------------------------------------------------------------
   // Helpers (private)
@@ -2743,28 +2801,63 @@ function markDone(deps) {
 
 // src/business/pipelines/execute/per-task-pipeline.ts
 function createPerTaskPipeline(deps, useCase, options = {}) {
+  const trace = withStepTrace(deps.signalBus);
   return pipeline("per-task", [
-    branchPreflight({ external: deps.external, persistence: deps.persistence }),
-    contractNegotiate({ persistence: deps.persistence, fs: deps.fs }),
-    markInProgress({ persistence: deps.persistence, signalBus: deps.signalBus }),
-    executeTask({ useCase, options, taskSessionIds: deps.taskSessionIds, logger: deps.logger }),
-    storeVerification({ persistence: deps.persistence, logger: deps.logger }),
-    postTaskCheck({ useCase }),
-    evaluateTask({
-      persistence: deps.persistence,
-      fs: deps.fs,
-      aiSession: deps.aiSession,
-      promptBuilder: deps.promptBuilder,
-      parser: deps.parser,
-      ui: deps.ui,
-      logger: deps.logger,
-      external: deps.external,
-      useCase,
-      options
-    }),
-    markDone({ persistence: deps.persistence, logger: deps.logger, signalBus: deps.signalBus })
+    trace(branchPreflight({ external: deps.external, persistence: deps.persistence })),
+    trace(contractNegotiate({ persistence: deps.persistence, fs: deps.fs })),
+    trace(markInProgress({ persistence: deps.persistence, signalBus: deps.signalBus })),
+    trace(executeTask({ useCase, options, taskSessionIds: deps.taskSessionIds, logger: deps.logger })),
+    trace(storeVerification({ persistence: deps.persistence, logger: deps.logger })),
+    trace(postTaskCheck({ useCase })),
+    trace(
+      evaluateTask({
+        persistence: deps.persistence,
+        fs: deps.fs,
+        aiSession: deps.aiSession,
+        promptBuilder: deps.promptBuilder,
+        parser: deps.parser,
+        ui: deps.ui,
+        logger: deps.logger,
+        external: deps.external,
+        useCase,
+        options
+      })
+    ),
+    trace(markDone({ persistence: deps.persistence, logger: deps.logger, signalBus: deps.signalBus }))
   ]);
 }
+function withStepTrace(signalBus) {
+  return (inner) => ({
+    name: inner.name,
+    execute: inner.execute,
+    hooks: {
+      pre: async (ctx) => {
+        signalBus.emit({
+          type: "task-step",
+          sprintId: ctx.sprint.id,
+          taskId: ctx.task.id,
+          stepName: inner.name,
+          phase: "start",
+          timestamp: /* @__PURE__ */ new Date()
+        });
+        const prior = await inner.hooks?.pre?.(ctx);
+        return prior ?? Result.ok(ctx);
+      },
+      post: async (ctx, result) => {
+        const prior = await inner.hooks?.post?.(ctx, result);
+        signalBus.emit({
+          type: "task-step",
+          sprintId: ctx.sprint.id,
+          taskId: ctx.task.id,
+          stepName: inner.name,
+          phase: "finish",
+          timestamp: /* @__PURE__ */ new Date()
+        });
+        return prior ?? Result.ok({});
+      }
+    }
+  });
+}
 
 // src/business/pipelines/execute.ts
 var EXIT_SUCCESS = 0;
@@ -3202,7 +3295,6 @@ function executeTasksStep(deps, options) {
         onSettle: (task, result) => {
           if (result === "success") {
             taskSessionIds.delete(task.id);
-            deps.logger.success(`Completed: ${task.name}`);
           }
         }
       },
@@ -4733,8 +4825,8 @@ var DefaultOutputParserAdapter = class {
 
 // src/integration/user-interaction-adapter.ts
 var InteractiveUserAdapter = class {
-  async confirm(message, defaultValue) {
-    return getPrompt().confirm({ message, default: defaultValue });
+  async confirm(message, defaultValue, details) {
+    return getPrompt().confirm({ message, default: defaultValue, details });
   }
   async selectPaths(reposByProject, message, preselected) {
     const choices = [];
@@ -4770,12 +4862,15 @@ var InteractiveUserAdapter = class {
     return name.trim();
   }
   async getFeedback(message) {
-    const response = await getPrompt().input({ message });
-    return response.trim().length > 0 ? response.trim() : null;
+    const response = await getPrompt().editor({ message, kind: "markdown" });
+    if (response == null) return null;
+    const trimmed = response.trim();
+    return trimmed.length > 0 ? trimmed : null;
   }
 };
 var AutoUserAdapter = class {
-  confirm(_message, defaultValue) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  confirm(_message, defaultValue, _details) {
     return Promise.resolve(defaultValue ?? true);
   }
   selectPaths(reposByProject, _message, preselected) {