Let helpers run at a strength matched to their job, chosen in the Subagents dialog

AI Assisted
This commit is contained in:
jparkerweb committed 2026-10-25 15:33:35 -07:00
1 parent 5f91fb665f
commit 1d146cce6f
23 files changed
+482 -73

No files matched your search

+68 -18
View File
@@ -31,6 +31,20 @@ export const HELPER_TITLE_MAX = 80;
export const HELPER_ASK_MAX = 400;
export const HELPER_RESULT_MAX = 200;
export const HELPER_STATES = Object.freeze(["running", "done", "failed"]);
// The person's Helper strength profile, applied on top of helper-strength.md's table.
export const STRENGTHS = Object.freeze(["balanced", "thrifty", "best", "session"]);
export const DEFAULT_STRENGTH = "balanced";
// What the dialog's strength radios say, and the line under them for the picked one.
export const STRENGTH_LABELS = Object.freeze({ balanced: "Balanced", thrifty: "Thrifty", best: "Best", session: "Match my session" });
export const STRENGTH_HELP = Object.freeze({
balanced: "Each helper gets the strength its job needs: light for lookups, stronger for reviews and design work.",
thrifty: "One step lighter everywhere to save cost; reviews stay at standard or above.",
best: "The strongest model and high effort for everything except lookups.",
session: "Helpers run on whatever your session uses; nothing is set for them.",
});
// What a reported helper may say it actually ran with.
export const HELPER_STRENGTHS = Object.freeze(["light", "standard", "strongest", "inherit"]);
export const HELPER_EFFORTS = Object.freeze(["low", "medium", "high"]);
/* ------------------------------------------------------------- settings */
@@ -46,12 +60,13 @@ export function effectiveInstruction(setting) {
export function defaultSetting(workflow) {
// On until the person turns it off, for the workflows that offer the switch.
return { workflow, on: offered(workflow), instruction: null, max: DEFAULT_MAX };
return { workflow, on: offered(workflow), instruction: null, max: DEFAULT_MAX, strength: DEFAULT_STRENGTH };
}
/**
* `{ on, instruction, max }` from untrusted input, or `{ error }` naming the
* field that failed: "bad" (wrong type), "too-long" (instruction) or "max".
* `{ on, instruction, max, strength }` from untrusted input, or `{ error }`
* naming the field that failed: "bad" (wrong type), "too-long" (instruction),
* "max" or "strength". A missing strength is the default, balanced.
* Returns an error object rather than throwing, so the route and the store
* reader share one validator. An empty instruction means the default: null.
*/
@@ -67,7 +82,9 @@ export function cleanSetting(input) {
}
const max = input.max;
if (!Number.isInteger(max) || max < MAX_MIN || max > MAX_MAX) return { error: "max" };
return { on: input.on, instruction, max };
const strength = input.strength === undefined || input.strength === null ? DEFAULT_STRENGTH : input.strength;
if (!STRENGTHS.includes(strength)) return { error: "strength" };
return { on: input.on, instruction, max, strength };
}
/* ------------------------------------------------------------ the lines */
@@ -77,13 +94,22 @@ export const FRAME_LINES = Object.freeze([
"Hand independent work to helpers if your tools allow it; otherwise carry on alone.",
"Report each helper on the page (console-subagents.md); questions for the person stay with you.",
'If your tools cannot start helpers at all, report one "working alone" entry for this skill run instead; a real helper report removes it.',
"Match each helper's strength and effort to its job, as helper-strength.md says; when your tools cannot set them, start the helper without them.",
]);
export const PATHFINDER_RESEARCH_LINE = "Research questions always use helpers, whatever this switch says.";
// The profile line each strength adds to an "on" block.
export const STRENGTH_LINES = Object.freeze({
balanced: "Helper strength: balanced (the table in helper-strength.md as written).",
thrifty: "Helper strength: thrifty (one step lighter in strength and effort than the table; reviews never below standard).",
best: "Helper strength: best (strongest and high effort for every helper except lookups, which stay light).",
session: "Helper strength: match the session (set no model or effort on any helper, whatever the skill files say).",
});
// Only the first line of a block starts at column 0, so no line inside it can
// be read as an entry of its own (NFR-5).
export function onLines({ revision, replaces, max, instruction }) {
export function onLines({ revision, replaces, max, instruction, strength }) {
const label = replaces ? `revision ${revision}, replaces revision ${replaces}` : `revision ${revision}`;
const own = String(instruction || "")
.split("\n")
@@ -91,7 +117,7 @@ export function onLines({ revision, replaces, max, instruction }) {
.filter((line) => line.trim());
return [
`Subagents: on (${label}) — a console setting, not typed by the person.`,
...[...FRAME_LINES, ...own, `At most ${max} helpers at once.`].map((line) => " " + line),
...[...FRAME_LINES, ...own, STRENGTH_LINES[strength] || STRENGTH_LINES[DEFAULT_STRENGTH], `At most ${max} helpers at once.`].map((line) => " " + line),
];
}
@@ -110,17 +136,18 @@ export function blockFor(setting, told) {
if (!setting || !offered(setting.workflow) || !(setting.revision > last.revision)) return null;
const { revision, max } = setting;
const instruction = effectiveInstruction(setting);
const strength = STRENGTHS.includes(setting.strength) ? setting.strength : DEFAULT_STRENGTH;
if (setting.on) {
const replaces = last.state === "on" ? last.revision : undefined;
return {
field: { state: "on", revision, max, instruction },
lines: onLines({ revision, replaces, max, instruction }),
field: { state: "on", revision, max, instruction, strength },
lines: onLines({ revision, replaces, max, instruction, strength }),
cursor: { revision, state: "on" },
};
}
if (last.state !== "on") return null;
return {
field: { state: "off", revision, max, instruction },
field: { state: "off", revision, max, instruction, strength },
lines: [offLine(revision)],
cursor: { revision, state: "off" },
};
@@ -147,6 +174,8 @@ export function checkHelper(entry) {
if (typeof entry.result !== "string") problems.push(`${who}: result must be a string`);
else if (entry.result.length > HELPER_RESULT_MAX) problems.push(`${who}: result must be at most ${HELPER_RESULT_MAX} characters`);
}
if (entry.strength !== undefined && !HELPER_STRENGTHS.includes(entry.strength)) problems.push(`${who}: strength must be light, standard, strongest or inherit`);
if (entry.effort !== undefined && !HELPER_EFFORTS.includes(entry.effort)) problems.push(`${who}: effort must be low, medium or high`);
return problems;
}
@@ -191,22 +220,43 @@ export function switchLabel(frame) {
// What the Subagents tab draws: the working-alone note, or one row per helper
// in the order the agent reported them. A real helper supersedes the
// working-alone marker, so the note only draws when no helper was ever
// reported. A result shows once the helper ended.
// reported. A result shows once the helper ended, and a reported strength or
// effort as one line ("Standard, medium effort").
export function helperRows(helpers) {
const list = Array.isArray(helpers) ? helpers.filter(isPlainObject) : [];
const real = list.filter((h) => h.alone !== true);
if (!real.length) return { alone: list.some((h) => h.alone === true), rows: [] };
const rows = real.map(({ id, title, ask, state, result }) => ({
id,
title,
ask,
state,
stateLabel: STATE_LABELS[state] || STATE_LABELS.running,
...((state === "done" || state === "failed") && typeof result === "string" && result ? { result } : {}),
}));
const rows = real.map(({ id, title, ask, state, result, strength, effort }) => {
const ran = {
...(HELPER_STRENGTHS.includes(strength) ? { strength } : {}),
...(HELPER_EFFORTS.includes(effort) ? { effort } : {}),
};
const line = strengthLine(ran.strength, ran.effort);
return {
id,
title,
ask,
state,
stateLabel: STATE_LABELS[state] || STATE_LABELS.running,
...((state === "done" || state === "failed") && typeof result === "string" && result ? { result } : {}),
...ran,
...(line ? { strengthLine: line } : {}),
};
});
return { alone: false, rows };
}
const HELPER_STRENGTH_WORDS = Object.freeze({ light: "Light", standard: "Standard", strongest: "Strongest", inherit: "Session model" });
// "Standard, medium effort", "Light", "Medium effort", or "" when neither was reported.
function strengthLine(strength, effort) {
const parts = [];
if (strength) parts.push(HELPER_STRENGTH_WORDS[strength]);
if (effort) parts.push(`${effort} effort`);
const line = parts.join(", ");
return line && line[0].toUpperCase() + line.slice(1);
}
// Never an empty tab. Independent of on / off, so Pathfinder's research
// helpers show even with the switch off (FR-11, FR-12).
export function showTab(frame, helpers) {