@a-t-h-i/bot-lobby 0.6.15 → 0.6.16

package/README.md

@@ -302,7 +302,7 @@ and your comments on it.
 
 ![The Plan tab](https://raw.githubusercontent.com/a-t-h-i/bot-lobby/main/docs/lobby-plan.png)
 
-The panel's questions, with recommended options, on the left; the draft plan
+The panel's questions, with their options, on the left; the draft plan
 on the right. See [Planning](#planning).
 
 ### Quick fix
@@ -497,7 +497,7 @@ has them as well.
 ### The questionnaire
 
 `ask_user_question` puts up to four questions to you in one pop-up in the
-lobby page, each with two to four options (the recommended one first).
+lobby page, each with two to four options. Agents do not recommend an answer, so you think it through; only a quite obvious one is marked `(Recommended)`.
 Questions, option descriptions and **previews** are Markdown: an option's
 preview (a layout sketch, a component mockup, a code snippet, a config) shows
 beside the list while that option is focused, under it in a narrow window, so
@@ -568,7 +568,7 @@ else TypeSafe.
 | Decision | Effect |
 | --- | --- |
 | Planning seats | Each round, only the seats the idea or your latest answers touch sit; `1`–`4` pins a seat |
-| Obvious answers | Answers a question itself when the conversation already makes the recommended option clearly right (≥ 0.9); listed under Assumptions |
+| Obvious answers | Answers a question itself when the conversation already makes an option marked `(Recommended)` clearly right (≥ 0.9); listed under Assumptions |
 | File hints | Agents start with a short list of the files they most likely need, and get a `find_relevant_files` tool |
 | Relevant knowledge | When an agent's knowledge, standards or decisions file is too long for its prompt (over 4,000 characters), Jev keeps the sections that bear on the step, and the prompt says how many it left out and where the whole file is, so the agent can read the rest. A file that fits goes in whole, untouched; standards are never left empty |
 | Quick fix or task | Whether one engineer can do a new request alone decides whether it goes to the [quick-fix agent](#quick-fix-or-the-team) (the oracle confirms) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.15",
+  "version": "0.6.16",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/prompts/master.md

@@ -71,14 +71,17 @@ otherwise. It is a hint, never a rule.
 
 When the user leaves your questions unanswered (they put them away, or
 `ask_user_question` says so), the decision is still theirs: never assume the
-answers, never fall back on the recommended options, and never carry on with
+answers, never fall back on a marked option, and never carry on with
 work that depends on them. Say in one short line that the questions are
 waiting, end your turn, and ask again when they next write.
 
-When you `clarify` with options, put your recommended option first and mark
-it `(Recommended)`. When the request already makes it clearly right, the
-classifier answers for you: the reply says so, the decision is recorded, and
-you mention it in the proposal so the user can amend it.
+When you `clarify`, do not recommend an answer: the point is that the user
+thinks the decision through. List the options neutrally (no `(Recommended)`
+marker, none first because you prefer it, no hint of your own pick) and let
+the user decide. Mark an option `(Recommended)` only when the answer is quite
+obvious from the request or the repository; then the classifier may answer for
+you: the reply says so, the decision is recorded, and you mention it in the
+proposal so the user can amend it.
 
 The designer worker may ask the user itself (outside auto mode): visual
 choices it cannot settle alone, shown with Markdown wireframes or rendered

package/prompts/panel.md

@@ -25,9 +25,12 @@ questions and the user's answers, and the oracle's current draft plan.
 - Ask at most two questions, the most important first. They go to the
   oracle, who picks at most four for the user each round across the whole
   panel and decides the rest with your recommendation, so make each one
-  short, plain and specific, and give it two to four options, your
-  recommendation first with `(Recommended)` after its label. The user can
-  always type their own answer instead, so do not add an "Other" option.
+  short, plain and specific, and give it two to four options in a neutral
+  order. Do not recommend one: the user should think the decision through.
+  Only when the answer is quite obvious from the conversation or the
+  repository, put that option first with `(Recommended)` after its label. The
+  user can always type their own answer instead, so do not add an "Other"
+  option.
 - Read the draft's Assumptions: if one the oracle made for your seat is
   wrong, say so under Notes and ask about it again.
 - If an answer from the user is vague or conflicts with what you see in the
@@ -44,11 +47,12 @@ OPEN or READY
 
 ## Questions
 1. The question, ending with a question mark?
-   - Short label (Recommended) — what choosing it means
+   - Short label — what choosing it means
    - Another label — what choosing it means
 
-(Two to four options per question, labels of one to five words. Omit
-Questions when READY.)
+(Two to four options per question, labels of one to five words, no
+recommendation unless the answer is quite obvious, and then only that option
+carries `(Recommended)`. Omit Questions when READY.)
 
 ## Notes
 - …

package/prompts/planner.md

@@ -6,8 +6,8 @@ without guessing. The panel's domain members — DEV, DESIGN, QA and RESEARCH
 bring you their questions each round, and you decide which ones reach the
 user: you own the plan and the questions. You are thorough but you spare the
 user: every decision that changes the implementation gets made, either by the
-user or by you with the recommended option, written down as an assumption the
-user can overrule. You never
+user or, when the answer is quite obvious, by you, written down as an
+assumption the user can overrule. You never
 write code and never change files; you may read the repository to ask
 informed questions and to ground the plan in what exists.
 
@@ -30,23 +30,26 @@ below.
   one of the questions.
 - Keep each question short and plain: one line the user can answer at a
   glance. Give it two to four options — labels of one to five words and a
-  short clause on what each means — your recommendation first with
-  `(Recommended)` after its label. The user answers all of them together in
-  one dialog and can type their own answer, so never add an "Other" option.
+  short clause on what each means — in a neutral order. Do not recommend an
+  option: the user should think each decision through. Only when the answer is
+  quite obvious from the conversation or the repository, put that option first
+  with `(Recommended)` after its label. The user answers all of them together
+  in one dialog and can type their own answer, so never add an "Other" option.
 - The conversation may carry an **Already settled with the user** list:
   questions the user answered (or left for you to decide). They are closed in
   any wording, so never ask one again, not even rephrased; fold the answer
   into the plan. The engine drops a repeat before the user sees it, so asking
   again only wastes a round. Ask about something new, or ask nothing.
 - Decide every question you do not ask, and any the user leaves unanswered,
-  with its recommended option, and list those decisions under
+  with the marked option where there is one and otherwise your best call, and
+  list those decisions under
   `### Assumptions` in the plan, one line each, so the user can see and
   overrule them.
 - Challenge answers that are vague, contradictory or risky, and ask again.
   Do not accept "whatever you think" for a decision with real trade-offs:
   propose one and ask the user to confirm it.
 - The conversation may show questions **decided by the classifier**: a
-  fast model answered them with their recommended option because the
+  fast model answered them with their marked option because the
   conversation already made it clearly right. Treat them as answered, list
   each under `### Assumptions` (the user can overrule it), and do not ask
   them again.
@@ -62,7 +65,7 @@ GRILLING.
 Planning may be limited to a number of rounds; your task says which round
 this is. Ask the questions that change the most early. In the final round,
 and in any round after it, no member runs and nothing more is asked: fold the
-answers into the plan, decide every open point with its recommended option,
+answers into the plan, decide every open point (the marked option where there is one, otherwise your best call),
 list each under `### Assumptions`, omit the Questions section and set the
 status READY.
 
@@ -76,12 +79,12 @@ Three to six words naming the task.
 
 ## Questions
 1. [DEV] The most important open question?
-   - Short label (Recommended) — what choosing it means
+   - Short label — what choosing it means
    - Another label — what choosing it means
 2. …
 
 (At most four questions, each tagged with its seat; two to four options per
-question, labels of one to five words. Omit the Questions section when READY
+question, labels of one to five words, `(Recommended)` only on an obvious one. Omit the Questions section when READY
 or when you decided everything yourself.)
 
 ## Plan

package/src/ask/tool.ts

@@ -26,7 +26,7 @@ const OptionSchema = Type.Object({
 const QuestionSchema = Type.Object({
   question: Type.String({ description: "The whole question, clear and specific, ending with a question mark. Markdown." }),
   header: Type.String({ maxLength: MAX_HEADER, description: `A short chip naming the question (at most ${MAX_HEADER} characters), e.g. "Auth" or "Layout".` }),
-  options: Type.Array(OptionSchema, { minItems: MIN_OPTIONS, maxItems: MAX_OPTIONS, description: `${MIN_OPTIONS}-${MAX_OPTIONS} distinct options. Put the one you recommend first and end its label with "(Recommended)". The user can always answer in their own words instead.` }),
+  options: Type.Array(OptionSchema, { minItems: MIN_OPTIONS, maxItems: MAX_OPTIONS, description: `${MIN_OPTIONS}-${MAX_OPTIONS} distinct options in a neutral order. Do not recommend one: the user should think the decision through. Only when the answer is quite obvious, put that option first and end its label with "(Recommended)". The user can always answer in their own words instead.` }),
   multiSelect: Type.Optional(Type.Boolean({ description: "True when several answers can apply together." })),
 });
 
@@ -36,7 +36,7 @@ export const AskParams = Type.Object({
 
 const DESCRIPTION = [
   "Ask the user one to four questions with options to pick from, when the answer would change what you do and you would otherwise guess.",
-  "Each question has 2-4 options (the one you recommend first, its label ending in \"(Recommended)\"); the user can pick one (or several with multiSelect), or answer in their own words.",
+  "Each question has 2-4 options in a neutral order, with no recommendation (mark one \"(Recommended)\", first, only when the answer is quite obvious); the user can pick one (or several with multiSelect), or answer in their own words.",
   "Questions, descriptions and previews are Markdown. Give options a `preview` when the user needs to see them to choose: a UI mockup, a layout sketch, a code snippet, a config; the focused option's preview shows beside the list. An option can also carry an `image` file (a screenshot, a rendered mockup).",
   "Do not use it for yes/no confirmations of what you were already told to do, or for questions the conversation already answers.",
 ].join(" ");

package/src/classifier/triage.ts

@@ -208,13 +208,14 @@ export function triageLine(triage: TaskTriage): string {
 
 /**
  * A clarify question the classifier can answer: its pick must be the
- * recommended option (marked `(Recommended)`, else the first), confident and
- * clearly ahead; otherwise the question goes to the user as before.
+ * recommended option (marked `(Recommended)`; an unmarked question always goes
+ * to the user), confident and clearly ahead.
  */
 export async function answerClarify(classifier: Classifier, question: string, options: readonly string[], context: { request: string; notes: string; proposal?: string }, signal?: AbortSignal): Promise<AutoAnswer | undefined> {
   if (options.length < 2 || !classifier.enabled("answers")) return undefined;
   const labels = options.map((option) => option.replace(/\s*\(recommended\)\s*/i, " ").trim());
   const marked = options.findIndex((option) => /\(recommended\)/i.test(option));
-  const decided = await autoAnswer(classifier, [{ index: 0, from: "MASTER", text: question, options: labels.map((label) => ({ label, description: "" })), recommended: labels[marked >= 0 ? marked : 0]! }], { request: context.request, conversation: context.notes, ...(context.proposal ? { draft: context.proposal } : {}) }, signal);
+  if (marked < 0) return undefined;
+  const decided = await autoAnswer(classifier, [{ index: 0, from: "MASTER", text: question, options: labels.map((label) => ({ label, description: "" })), recommended: labels[marked]! }], { request: context.request, conversation: context.notes, ...(context.proposal ? { draft: context.proposal } : {}) }, signal);
   return decided?.[0];
 }

package/src/lobby/ask.ts

@@ -1,7 +1,7 @@
 /**
  * The oracle puts the planning panel's questions to the user through the
- * questionnaire (`../ask`): a card per question with each seat's options, the
- * recommended one first, and a field for an answer in the user's own words.
+ * questionnaire (`../ask`): a card per question with each seat's options (the
+ * recommended one first when the answer is obvious), and a field for an answer in the user's own words.
  * The panel's questions become questionnaires of at most four, and the
  * answers become the user's turn for the next round.
  */

package/src/lobby/planner.ts

@@ -173,10 +173,10 @@ export function roundMode(round: number, limit: number): RoundMode {
 /** What the oracle is told to do at the end of its task, by round mode. */
 export function oracleClosing(mode: RoundMode, round: number, limit: number): string {
   if (mode === "final") {
-    return `Final round (${round} of ${limit}): no seat runs this round and nothing more is asked. Fold the user's answers into the plan, decide every point still open with its recommended option and list each under ### Assumptions, and set Status READY. Omit the Questions section. Reply in the required output format.`;
+    return `Final round (${round} of ${limit}): no seat runs this round and nothing more is asked. Fold the user's answers into the plan, decide every point still open (with its marked option where there is one, otherwise your best call) and list each under ### Assumptions, and set Status READY. Omit the Questions section. Reply in the required output format.`;
   }
   if (mode === "revise") {
-    return `The planning round limit (${limit}) is reached: revise the plan for the user's latest message and comments. Ask nothing; decide anything open with its recommended option under ### Assumptions, and keep Status READY. Omit the Questions section. Reply in the required output format.`;
+    return `The planning round limit (${limit}) is reached: revise the plan for the user's latest message and comments. Ask nothing; decide anything open (with its marked option where there is one, otherwise your best call) under ### Assumptions, and keep Status READY. Omit the Questions section. Reply in the required output format.`;
   }
   const bound = limit > 0 ? `Round ${round} of ${limit}; in round ${limit} you settle whatever is still open alone, so ask the decisive questions now. ` : "";
   return `${bound}Continue: fold the panel's notes and the user's answers into the plan, ask what no seat owns, or declare the plan READY. Reply in the required output format.`;
@@ -225,9 +225,9 @@ export function parseOption(text: string): PanelOption {
   return split ? { label: split[1]!.trim(), description: split[2]!.trim() } : { label: flat, description: "" };
 }
 
-/** The option the asker recommends: the one marked `(Recommended)`, else the first. */
+/** The option the asker recommends: only the one marked `(Recommended)`; nothing is implied by order. */
 export function recommendedOption(question: AskedQuestion): PanelOption | undefined {
-  return question.options.find((option) => /\(recommended\)/i.test(option.label)) ?? question.options[0];
+  return question.options.find((option) => /\(recommended\)/i.test(option.label));
 }
 
 /** An option's label without its `(Recommended)` marker. */

package/src/lobby/split.ts

@@ -171,7 +171,7 @@ export function splitQuestion(input: { stepCount: number; proposal: SplitProposa
       last ? "This is the last revision: take it, or keep the plan whole." : "Type what to change (for example *merge 2 and 3*) to revise it.",
     ].join("\n\n"),
     options: [
-      { label: `${splitLabel(count)} (Recommended)`, description: "Each part is saved as its own pending task, in order, knowing the others.", preview: splitPreview(input.proposal, input.steps) },
+      { label: splitLabel(count), description: "Each part is saved as its own pending task, in order, knowing the others.", preview: splitPreview(input.proposal, input.steps) },
       { label: "Keep it as one task", description: `One task with all ${input.stepCount} steps.` },
     ],
   };

package/src/pi/tools.ts

@@ -27,7 +27,7 @@ const OrchestrateSchema = Type.Object({
   action: StringEnum(ORCHESTRATE_ACTIONS, { description: "Workflow step to run" }),
   taskId: Type.Optional(Type.String({ description: "Task id; defaults to the active task" })),
   question: Type.Optional(Type.String({ description: "clarify: question for the user" })),
-  options: Type.Optional(Type.Array(Type.String(), { description: "clarify: optional answer choices; put your recommended one first and mark it (Recommended)" })),
+  options: Type.Optional(Type.Array(Type.String(), { description: "clarify: optional answer choices, neutral and unranked; mark one (Recommended) only when the answer is quite obvious" })),
   domains: Type.Optional(Type.Array(Type.String(), { description: "scout: any of designer, backend, qa" })),
   instruction: Type.Optional(Type.String({ description: "scout/research: a self-contained brief: the specific questions, where to look, the answer format you want (paths, names, versions, evidence) and what you will do with it. The agent may be a small model: assume nothing" })),
   proposal: Type.Optional(Type.String({ description: "propose: the user-facing proposal as a short `- ` bullet list, one line per change" })),