@pify/ask-question 0.2.0 → 0.3.0

package/README.md

@@ -10,6 +10,7 @@ Part of the [Pify suite](https://github.com/pifydev). Install with [`pify instal
 - **Built entirely on pi's built-in dialogs** (`select`/`input`) — no custom TUI overlay, so it works identically in the terminal and RPC/GUI hosts and can't break with pi UI changes. Multi-select is a checkbox toggle loop with `✓ Done`.
 - **Discipline encoded in the tool description** (zhushanwen's three conditions): only when 2+ reasonable approaches exist, context is already gathered, and a wrong pick means rework. Never for permissions or things the agent can look up.
 - **Declining is an answer**: Esc cleanly reports "the user declined" for the rest of the batch — no error, no re-asking. Headless runs get the full questionnaire back — every question with its options — plus "proceed with your best judgment and say which option you assumed", so the decision stays in the CI transcript instead of vanishing (asking is advisory, unlike the fail-closed safety gates).
+- **The decisions stay on the record** (v0.3): every questionnaire is appended to the session as its own entry, and `/ask` prints the last one (`/ask all` for the whole history) with what you chose or declined. Forks and `/reload` keep their own history, because the entries live on the branch.
 - **Rows the user can actually pick** (v0.2): two options sharing a label, or one labelled `Other…`, used to render as indistinguishable rows where the second was unselectable. Duplicates are now suffixed, reserved labels renamed, and every pick resolves by its position in the dialog rather than by its text.
 - Structured results return to the model as both readable text and `details.answers`.
 

package/extensions/ask-question.ts

@@ -20,12 +20,16 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { Type } from "typebox";
 
 import {
+  ASK_STATE,
   DONE_LABEL,
   OTHER_LABEL,
   formatAnswers,
   headlessText,
+  parseAskRoute,
   parseSingleRow,
   parseToggleRow,
+  replayRounds,
+  routeText,
   singleRows,
   toggleRows,
   validateQuestions,
@@ -132,6 +136,10 @@ export default function askQuestion(pi: ExtensionAPI) {
         }
       }
 
+      // Record the round so /ask can show it later, and a fork keeps its own
+      // history; appended per round, never overwritten.
+      pi.appendEntry(ASK_STATE, { timestamp: Date.now(), answers });
+
       const text = [
         formatAnswers(answers),
         ...(result.warnings.length > 0 ? [`Warnings: ${result.warnings.join("; ")}`] : []),
@@ -139,4 +147,13 @@ export default function askQuestion(pi: ExtensionAPI) {
       return { content: [{ type: "text", text }], details: { answers } };
     },
   });
+
+  pi.registerCommand("ask", {
+    description: "Show what the agent asked you and how you answered: /ask [last | all]",
+    handler: async (args, ctx) => {
+      if (!ctx.hasUI) return;
+      const rounds = replayRounds(ctx.sessionManager.getBranch() as never);
+      ctx.ui.notify(routeText(parseAskRoute(args ?? ""), rounds), "info");
+    },
+  });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pify/ask-question",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Let the model ask instead of guessing: CC AskUserQuestion-shaped tool on built-in dialogs - 1-4 questions, multi-select, Other free-text, works in TUI and RPC",
   "keywords": [
     "pi-package",

package/src/ask.ts

@@ -184,6 +184,80 @@ export function headlessText(questions: AskQuestion[]): string {
   ].join("\n");
 }
 
+export const ASK_STATE = "ask-question-round";
+
+export interface AskRound {
+  timestamp: number;
+  answers: AskAnswer[];
+}
+
+export interface BranchEntryLike {
+  type?: string;
+  customType?: string;
+  data?: unknown;
+  [key: string]: unknown;
+}
+
+/**
+ * Every questionnaire is appended as its own entry (not a last-wins
+ * snapshot): the point of the record is the sequence of decisions, and an
+ * earlier answer stays true after a later one is given.
+ */
+export function replayRounds(entries: BranchEntryLike[]): AskRound[] {
+  const rounds: AskRound[] = [];
+  for (const entry of entries) {
+    if (entry.type !== "custom" || entry.customType !== ASK_STATE) continue;
+    const data = entry.data;
+    if (!isRecord(data) || !Array.isArray(data.answers)) continue;
+    rounds.push({
+      timestamp: typeof data.timestamp === "number" ? data.timestamp : 0,
+      answers: data.answers as AskAnswer[],
+    });
+  }
+  return rounds;
+}
+
+export type AskRoute = { kind: "last" } | { kind: "all" } | { kind: "help" } | { kind: "unknown"; input: string };
+
+export const ASK_USAGE = "Usage: /ask [last | all]";
+
+export function parseAskRoute(raw: string): AskRoute {
+  const text = (raw ?? "").trim().toLowerCase();
+  if (!text || text === "last") return { kind: "last" };
+  if (text === "all" || text === "history") return { kind: "all" };
+  if (text === "help" || text === "?") return { kind: "help" };
+  return { kind: "unknown", input: text };
+}
+
+function stamp(timestamp: number): string {
+  if (!timestamp) return "";
+  const d = new Date(timestamp);
+  const pad = (n: number) => String(n).padStart(2, "0");
+  return `${pad(d.getHours())}:${pad(d.getMinutes())} `;
+}
+
+/** What /ask prints. */
+export function routeText(route: AskRoute, rounds: AskRound[]): string {
+  switch (route.kind) {
+    case "help":
+      return ASK_USAGE;
+    case "unknown":
+      return `Unknown route "${route.input}". ${ASK_USAGE}`;
+    case "last": {
+      const last = rounds[rounds.length - 1];
+      return last
+        ? `${stamp(last.timestamp)}last questionnaire\n${formatAnswers(last.answers)}`
+        : "No questions have been asked in this session.";
+    }
+    case "all":
+      return rounds.length === 0
+        ? "No questions have been asked in this session."
+        : rounds
+            .map((round, i) => `#${i + 1} ${stamp(round.timestamp)}\n${formatAnswers(round.answers)}`)
+            .join("\n\n");
+  }
+}
+
 /** Text block the model receives. */
 export function formatAnswers(answers: AskAnswer[]): string {
   return answers