@caupulican/pi-adaptative 0.80.86 → 0.80.89

package/dist/modes/interactive/components/settings-selector.js

@@ -1,6 +1,6 @@
 import { Container, getCapabilities, getKeybindings, Input, SelectList, SettingsList, Spacer, Text, } from "@caupulican/pi-tui";
 import { formatHttpIdleTimeoutMs, HTTP_IDLE_TIMEOUT_CHOICES } from "../../../core/http-dispatcher.js";
-import { DEFAULT_AUTONOMY_MAX_STALL_TURNS } from "../../../core/settings-manager.js";
+import { DEFAULT_AUTONOMY_GOAL_AUTO_CONTINUE, DEFAULT_AUTONOMY_GOAL_AUTO_CONTINUE_DELAY_MS, DEFAULT_AUTONOMY_GOAL_CONTINUE_MAX_WALL_CLOCK_MINUTES, DEFAULT_AUTONOMY_GOAL_CONTINUE_TURNS, DEFAULT_AUTONOMY_MAX_STALL_TURNS, DEFAULT_RESEARCH_LANE_ENABLED, DEFAULT_RESEARCH_LANE_IDLE_DELAY_MS, DEFAULT_RESEARCH_LANE_MAX_RUNS_PER_SESSION, DEFAULT_RESEARCH_LANE_MAX_USD, DEFAULT_RESEARCH_LANE_MAX_WALL_CLOCK_MS, DEFAULT_WORKER_DELEGATION_ENABLED, DEFAULT_WORKER_DELEGATION_MAX_USD, DEFAULT_WORKER_DELEGATION_MAX_WALL_CLOCK_MS, } from "../../../core/settings-manager.js";
 import { getSelectListTheme, getSettingsListTheme, theme } from "../theme/theme.js";
 import { DynamicBorder } from "./dynamic-border.js";
 import { keyDisplayText } from "./keybinding-hints.js";
@@ -19,7 +19,27 @@ const THINKING_DESCRIPTIONS = {
     xhigh: "Maximum reasoning (~32k tokens)",
 };
 const AUTONOMY_MODES = ["off", "safe", "balanced", "full"];
-const AUTONOMY_MAX_STALL_TURN_VALUES = ["0", "5", "10", "20", "30", "50"];
+const AUTONOMY_GOAL_CONTINUE_TURN_VALUES = ["1", "3", "5", "10", "20"];
+const AUTONOMY_MAX_STALL_TURN_VALUES = ["0", "5", "10", "20", "30", "50", "100"];
+const AUTONOMY_GOAL_CONTINUE_MAX_WALL_CLOCK_MINUTE_VALUES = ["0", "15", "30", "60", "120", "240", "480", "1440"];
+const AUTONOMY_GOAL_AUTO_CONTINUE_DELAY_MS_VALUES = ["0", "250", "1000", "5000", "30000", "60000"];
+const RESEARCH_LANE_MAX_USD_VALUES = ["0.05", "0.1", "0.25", "0.5", "1", "2"];
+const RESEARCH_LANE_MAX_WALL_CLOCK_MS_VALUES = ["0", "30000", "60000", "120000", "300000", "600000"];
+const RESEARCH_LANE_IDLE_DELAY_MS_VALUES = ["0", "250", "1000", "5000", "30000", "60000"];
+const RESEARCH_LANE_MAX_RUNS_PER_SESSION_VALUES = ["0", "1", "3", "5", "10", "25", "50"];
+const CONTEXT_POLICY_PRESERVE_RECENT_MESSAGES_VALUES = ["2", "4", "8", "16", "32"];
+const CONTEXT_POLICY_MIN_CHARS_VALUES = ["300", "600", "1200", "2400", "4800"];
+const CONTEXT_POLICY_ENFORCEMENT_DEFAULTS = {
+    enabled: false,
+    preserveRecentMessages: 8,
+    minChars: 1200,
+};
+const CONTEXT_MEMORY_RETRIEVAL_MAX_RESULTS_VALUES = ["1", "3", "5", "10", "20"];
+const CONTEXT_MEMORY_RETRIEVAL_DEFAULTS = {
+    enabled: false,
+    maxResults: 5,
+    includeInPrompt: false,
+};
 const AUTO_LEARN_DEFAULTS = {
     model: "active",
     longSessionMessages: 32,
@@ -61,20 +81,65 @@ function autonomyModeValue(settings) {
 }
 function autonomySummary(settings) {
     const mode = autonomyModeValue(settings);
-    const rounds = settings.maxStallTurns ?? DEFAULT_AUTONOMY_MAX_STALL_TURNS;
+    const turns = settings.goalContinueTurns ?? DEFAULT_AUTONOMY_GOAL_CONTINUE_TURNS;
+    const stall = settings.maxStallTurns ?? DEFAULT_AUTONOMY_MAX_STALL_TURNS;
+    const autoContinue = settings.goalAutoContinue ?? DEFAULT_AUTONOMY_GOAL_AUTO_CONTINUE;
     const modeLabel = mode === "full" ? "standing autonomy" : mode;
-    return `${modeLabel}, ${rounds} rounds`;
+    return `${modeLabel}, ${turns} turns, stall ${stall}, auto ${autoContinue ? "on" : "off"}`;
+}
+function autonomyGoalContinueTurnsValue(settings) {
+    return String(settings.goalContinueTurns ?? DEFAULT_AUTONOMY_GOAL_CONTINUE_TURNS);
 }
 function autonomyMaxStallTurnsValue(settings) {
-    const rounds = settings.maxStallTurns ?? DEFAULT_AUTONOMY_MAX_STALL_TURNS;
-    return String(rounds);
+    return String(settings.maxStallTurns ?? DEFAULT_AUTONOMY_MAX_STALL_TURNS);
+}
+function autonomyGoalContinueMaxWallClockMinutesValue(settings) {
+    return String(settings.goalContinueMaxWallClockMinutes ?? DEFAULT_AUTONOMY_GOAL_CONTINUE_MAX_WALL_CLOCK_MINUTES);
+}
+function autonomyGoalAutoContinueValue(settings) {
+    return String(settings.goalAutoContinue ?? DEFAULT_AUTONOMY_GOAL_AUTO_CONTINUE);
+}
+function autonomyGoalAutoContinueDelayMsValue(settings) {
+    return String(settings.goalAutoContinueDelayMs ?? DEFAULT_AUTONOMY_GOAL_AUTO_CONTINUE_DELAY_MS);
+}
+function researchLaneSummary(settings) {
+    if (!(settings.enabled ?? DEFAULT_RESEARCH_LANE_ENABLED))
+        return "disabled";
+    const maxUsd = settings.maxUsd ?? DEFAULT_RESEARCH_LANE_MAX_USD;
+    const maxRuns = settings.maxRunsPerSession ?? DEFAULT_RESEARCH_LANE_MAX_RUNS_PER_SESSION;
+    return `enabled ($${maxUsd}/pass, ${maxRuns} runs/session)`;
+}
+function contextCurationSummary(settings) {
+    if (!settings.enabled)
+        return "disabled";
+    return `on · ${settings.model ?? "no model"} · ${settings.maxJobsPerTurn ?? 4} jobs/turn`;
+}
+function workerDelegationSummary(settings) {
+    if (!(settings.enabled ?? DEFAULT_WORKER_DELEGATION_ENABLED))
+        return "disabled";
+    const maxUsd = settings.maxUsd ?? DEFAULT_WORKER_DELEGATION_MAX_USD;
+    return `enabled ($${maxUsd}/worker)`;
 }
 function autoLearnSummary(settings) {
     return settings.enabled ? `enabled (${autoLearnModelValue(settings)})` : "disabled";
 }
+function contextPolicyEnforcementSummary(settings) {
+    if (!(settings.enabled ?? CONTEXT_POLICY_ENFORCEMENT_DEFAULTS.enabled))
+        return "disabled";
+    const preserve = settings.preserveRecentMessages ?? CONTEXT_POLICY_ENFORCEMENT_DEFAULTS.preserveRecentMessages;
+    const minChars = settings.minChars ?? CONTEXT_POLICY_ENFORCEMENT_DEFAULTS.minChars;
+    return `enabled (preserve ${preserve}, min ${minChars} chars)`;
+}
+function contextMemoryRetrievalSummary(settings) {
+    if (!(settings.enabled ?? CONTEXT_MEMORY_RETRIEVAL_DEFAULTS.enabled))
+        return "disabled";
+    const maxResults = settings.maxResults ?? CONTEXT_MEMORY_RETRIEVAL_DEFAULTS.maxResults;
+    const includeInPrompt = settings.includeInPrompt ?? CONTEXT_MEMORY_RETRIEVAL_DEFAULTS.includeInPrompt;
+    return `enabled (max ${maxResults} results${includeInPrompt ? ", in prompt" : ""})`;
+}
 function modelRouterSummary(settings) {
     const state = settings.enabled ? "enabled" : "disabled";
-    return `${state} · cheap: ${optionalStringValue(settings.cheapModel)} · expensive: ${optionalStringValue(settings.expensiveModel)} · learn: ${optionalStringValue(settings.learningModel, "active")}`;
+    return `${state} · cheap: ${optionalStringValue(settings.cheapModel)} · medium: ${optionalStringValue(settings.mediumModel)} · expensive: ${optionalStringValue(settings.expensiveModel)} · learn: ${optionalStringValue(settings.learningModel, "active")}`;
 }
 function buildAutoLearnModelOptions(settings, configuredModelOptions, currentModelPattern) {
     const currentValue = autoLearnModelValue(settings);
@@ -305,6 +370,10 @@ class AutonomySettingsSubmenu extends Container {
         this.state = {
             mode: autonomyModeValue(settings),
             maxStallTurns: settings.maxStallTurns ?? DEFAULT_AUTONOMY_MAX_STALL_TURNS,
+            goalContinueTurns: settings.goalContinueTurns ?? DEFAULT_AUTONOMY_GOAL_CONTINUE_TURNS,
+            goalContinueMaxWallClockMinutes: settings.goalContinueMaxWallClockMinutes ?? DEFAULT_AUTONOMY_GOAL_CONTINUE_MAX_WALL_CLOCK_MINUTES,
+            goalAutoContinue: settings.goalAutoContinue ?? DEFAULT_AUTONOMY_GOAL_AUTO_CONTINUE,
+            goalAutoContinueDelayMs: settings.goalAutoContinueDelayMs ?? DEFAULT_AUTONOMY_GOAL_AUTO_CONTINUE_DELAY_MS,
         };
         this.scope = scope;
         const items = [
@@ -323,12 +392,40 @@ class AutonomySettingsSubmenu extends Container {
                 values: AUTONOMY_MODES,
             },
             {
-                id: "autonomy-goal-loop-rounds",
-                label: "Goal loop rounds",
-                description: "Maximum provider rounds in one foreground goal loop before Pi stops continuing",
+                id: "autonomy-goal-auto-continue",
+                label: "Goal auto-continue",
+                description: "Inject bounded continuation prompts when Pi becomes idle with an active open goal",
+                currentValue: autonomyGoalAutoContinueValue(this.state),
+                values: ["true", "false"],
+            },
+            {
+                id: "autonomy-goal-continue-turns",
+                label: "Goal turns",
+                description: "Maximum continuation prompts in one idle or explicit goal loop",
+                currentValue: autonomyGoalContinueTurnsValue(this.state),
+                values: AUTONOMY_GOAL_CONTINUE_TURN_VALUES,
+            },
+            {
+                id: "autonomy-max-stall-turns",
+                label: "Goal stall limit",
+                description: "Maximum no-progress rounds before Pi stops continuing and asks the user",
                 currentValue: autonomyMaxStallTurnsValue(this.state),
                 values: AUTONOMY_MAX_STALL_TURN_VALUES,
             },
+            {
+                id: "autonomy-goal-wall-clock-minutes",
+                label: "Goal max minutes",
+                description: "Wall-clock budget per goal continuation loop; 0 disables the time budget",
+                currentValue: autonomyGoalContinueMaxWallClockMinutesValue(this.state),
+                values: AUTONOMY_GOAL_CONTINUE_MAX_WALL_CLOCK_MINUTE_VALUES,
+            },
+            {
+                id: "autonomy-goal-auto-continue-delay-ms",
+                label: "Goal delay ms",
+                description: "Delay before idle auto-continuation starts; 0 starts immediately after idle",
+                currentValue: autonomyGoalAutoContinueDelayMsValue(this.state),
+                values: AUTONOMY_GOAL_AUTO_CONTINUE_DELAY_MS_VALUES,
+            },
         ];
         this.settingsList = new SettingsList(items, Math.min(items.length, 10), getSettingsListTheme(), (id, newValue) => {
             switch (id) {
@@ -338,9 +435,247 @@ class AutonomySettingsSubmenu extends Container {
                 case "autonomy-mode":
                     this.state = { ...this.state, mode: newValue };
                     break;
-                case "autonomy-goal-loop-rounds":
+                case "autonomy-goal-auto-continue":
+                    this.state = { ...this.state, goalAutoContinue: newValue === "true" };
+                    break;
+                case "autonomy-goal-continue-turns":
+                    this.state = { ...this.state, goalContinueTurns: Number(newValue) };
+                    break;
+                case "autonomy-max-stall-turns":
                     this.state = { ...this.state, maxStallTurns: Number(newValue) };
                     break;
+                case "autonomy-goal-wall-clock-minutes":
+                    this.state = { ...this.state, goalContinueMaxWallClockMinutes: Number(newValue) };
+                    break;
+                case "autonomy-goal-auto-continue-delay-ms":
+                    this.state = { ...this.state, goalAutoContinueDelayMs: Number(newValue) };
+                    break;
+                default:
+                    return;
+            }
+            onChange({ ...this.state }, this.scope);
+        }, onCancel);
+        this.addChild(this.settingsList);
+    }
+    handleInput(data) {
+        this.settingsList.handleInput(data);
+    }
+}
+class ResearchLaneSettingsSubmenu extends Container {
+    settingsList;
+    state;
+    scope;
+    constructor(settings, onChange, onCancel, scope = "global") {
+        super();
+        this.state = {
+            ...settings,
+            enabled: settings.enabled ?? DEFAULT_RESEARCH_LANE_ENABLED,
+            maxUsd: settings.maxUsd ?? DEFAULT_RESEARCH_LANE_MAX_USD,
+            maxWallClockMs: settings.maxWallClockMs ?? DEFAULT_RESEARCH_LANE_MAX_WALL_CLOCK_MS,
+            idleDelayMs: settings.idleDelayMs ?? DEFAULT_RESEARCH_LANE_IDLE_DELAY_MS,
+            maxRunsPerSession: settings.maxRunsPerSession ?? DEFAULT_RESEARCH_LANE_MAX_RUNS_PER_SESSION,
+        };
+        this.scope = scope;
+        const items = [
+            {
+                id: "research-lane-scope",
+                label: "Save scope",
+                description: "Save these research-lane settings globally or in the current project's .pi/settings.json",
+                currentValue: this.scope,
+                values: ["global", "project"],
+            },
+            {
+                id: "research-lane-enabled",
+                label: "Enabled",
+                description: "Run bounded, read-only background research when idle with an active goal (requires autonomy mode on)",
+                currentValue: String(this.state.enabled),
+                values: ["true", "false"],
+            },
+            {
+                id: "research-lane-max-usd",
+                label: "Budget per pass",
+                description: "USD budget per research pass; breaches mark the lane budget_exhausted in diagnostics",
+                currentValue: String(this.state.maxUsd),
+                values: RESEARCH_LANE_MAX_USD_VALUES,
+            },
+            {
+                id: "research-lane-max-wall-clock-ms",
+                label: "Max milliseconds",
+                description: "Wall-clock budget per research pass; 0 disables the time budget",
+                currentValue: String(this.state.maxWallClockMs),
+                values: RESEARCH_LANE_MAX_WALL_CLOCK_MS_VALUES,
+            },
+            {
+                id: "research-lane-idle-delay-ms",
+                label: "Idle delay ms",
+                description: "Delay before idle-triggered research starts; 0 starts immediately after idle",
+                currentValue: String(this.state.idleDelayMs),
+                values: RESEARCH_LANE_IDLE_DELAY_MS_VALUES,
+            },
+            {
+                id: "research-lane-max-runs-per-session",
+                label: "Runs per session",
+                description: "Maximum idle-triggered research passes per session; explicit /autonomy research is uncapped",
+                currentValue: String(this.state.maxRunsPerSession),
+                values: RESEARCH_LANE_MAX_RUNS_PER_SESSION_VALUES,
+            },
+        ];
+        this.settingsList = new SettingsList(items, Math.min(items.length, 10), getSettingsListTheme(), (id, newValue) => {
+            switch (id) {
+                case "research-lane-scope":
+                    this.scope = newValue;
+                    break;
+                case "research-lane-enabled":
+                    this.state = { ...this.state, enabled: newValue === "true" };
+                    break;
+                case "research-lane-max-usd":
+                    this.state = { ...this.state, maxUsd: Number(newValue) };
+                    break;
+                case "research-lane-max-wall-clock-ms":
+                    this.state = { ...this.state, maxWallClockMs: Number(newValue) };
+                    break;
+                case "research-lane-idle-delay-ms":
+                    this.state = { ...this.state, idleDelayMs: Number(newValue) };
+                    break;
+                case "research-lane-max-runs-per-session":
+                    this.state = { ...this.state, maxRunsPerSession: Number(newValue) };
+                    break;
+                default:
+                    return;
+            }
+            onChange({ ...this.state }, this.scope);
+        }, onCancel);
+        this.addChild(this.settingsList);
+    }
+    handleInput(data) {
+        this.settingsList.handleInput(data);
+    }
+}
+class ContextCurationSettingsSubmenu extends Container {
+    settingsList;
+    state;
+    scope;
+    constructor(settings, modelOptions, onChange, onCancel, scope = "global") {
+        super();
+        this.state = {
+            ...settings,
+            enabled: settings.enabled ?? false,
+            maxJobsPerTurn: settings.maxJobsPerTurn ?? 4,
+        };
+        this.scope = scope;
+        const modelValues = ["(unset)", ...(modelOptions ?? []).map((option) => option.value).filter(Boolean)];
+        const items = [
+            {
+                id: "context-curation-scope",
+                label: "Save scope",
+                description: "Save these curation settings globally or in the current project's .pi/settings.json",
+                currentValue: this.scope,
+                values: ["global", "project"],
+            },
+            {
+                id: "context-curation-enabled",
+                label: "Enabled",
+                description: "Local brain curator: digests GC-packed stubs and scores stale-chunk relevance. Requires a digest-fit local model (run /fitness <model>).",
+                currentValue: String(this.state.enabled),
+                values: ["true", "false"],
+            },
+            {
+                id: "context-curation-model",
+                label: "Curator model",
+                description: "Local model that runs curation jobs; refused until it passes the digest fitness probe on this host",
+                currentValue: this.state.model ?? "(unset)",
+                values: modelValues,
+            },
+            {
+                id: "context-curation-max-jobs",
+                label: "Max jobs per turn",
+                description: "Curation jobs drained per turn (each is one small local completion)",
+                currentValue: String(this.state.maxJobsPerTurn),
+                values: ["1", "2", "4", "8", "16"],
+            },
+        ];
+        this.settingsList = new SettingsList(items, Math.min(items.length, 10), getSettingsListTheme(), (id, newValue) => {
+            switch (id) {
+                case "context-curation-scope":
+                    this.scope = newValue;
+                    break;
+                case "context-curation-enabled":
+                    this.state = { ...this.state, enabled: newValue === "true" };
+                    break;
+                case "context-curation-model":
+                    this.state = { ...this.state, model: newValue === "(unset)" ? undefined : newValue };
+                    break;
+                case "context-curation-max-jobs":
+                    this.state = { ...this.state, maxJobsPerTurn: Number(newValue) };
+                    break;
+                default:
+                    return;
+            }
+            onChange({ ...this.state }, this.scope);
+        }, onCancel);
+        this.addChild(this.settingsList);
+    }
+    handleInput(data) {
+        this.settingsList.handleInput(data);
+    }
+}
+class WorkerDelegationSettingsSubmenu extends Container {
+    settingsList;
+    state;
+    scope;
+    constructor(settings, onChange, onCancel, scope = "global") {
+        super();
+        this.state = {
+            ...settings,
+            enabled: settings.enabled ?? DEFAULT_WORKER_DELEGATION_ENABLED,
+            maxUsd: settings.maxUsd ?? DEFAULT_WORKER_DELEGATION_MAX_USD,
+            maxWallClockMs: settings.maxWallClockMs ?? DEFAULT_WORKER_DELEGATION_MAX_WALL_CLOCK_MS,
+        };
+        this.scope = scope;
+        const items = [
+            {
+                id: "worker-delegation-scope",
+                label: "Save scope",
+                description: "Save these delegation settings globally or in the current project's .pi/settings.json",
+                currentValue: this.scope,
+                values: ["global", "project"],
+            },
+            {
+                id: "worker-delegation-enabled",
+                label: "Enabled",
+                description: "Allow the delegate tool to run bounded, read-only scout workers on a cheap model lane",
+                currentValue: String(this.state.enabled),
+                values: ["true", "false"],
+            },
+            {
+                id: "worker-delegation-max-usd",
+                label: "Budget per worker",
+                description: "USD budget per delegated worker; breaches mark the lane budget_exhausted in diagnostics",
+                currentValue: String(this.state.maxUsd),
+                values: RESEARCH_LANE_MAX_USD_VALUES,
+            },
+            {
+                id: "worker-delegation-max-wall-clock-ms",
+                label: "Max milliseconds",
+                description: "Wall-clock budget per delegated worker; 0 disables the time budget",
+                currentValue: String(this.state.maxWallClockMs),
+                values: RESEARCH_LANE_MAX_WALL_CLOCK_MS_VALUES,
+            },
+        ];
+        this.settingsList = new SettingsList(items, Math.min(items.length, 10), getSettingsListTheme(), (id, newValue) => {
+            switch (id) {
+                case "worker-delegation-scope":
+                    this.scope = newValue;
+                    break;
+                case "worker-delegation-enabled":
+                    this.state = { ...this.state, enabled: newValue === "true" };
+                    break;
+                case "worker-delegation-max-usd":
+                    this.state = { ...this.state, maxUsd: Number(newValue) };
+                    break;
+                case "worker-delegation-max-wall-clock-ms":
+                    this.state = { ...this.state, maxWallClockMs: Number(newValue) };
+                    break;
                 default:
                     return;
             }
@@ -500,6 +835,132 @@ class AutoLearnSettingsSubmenu extends Container {
         this.settingsList.handleInput(data);
     }
 }
+class ContextPolicyEnforcementSettingsSubmenu extends Container {
+    settingsList;
+    state;
+    scope;
+    constructor(settings, onChange, onCancel, scope = "global") {
+        super();
+        this.state = { ...settings };
+        this.scope = scope;
+        const items = [
+            {
+                id: "context-policy-scope",
+                label: "Save scope",
+                description: "Save this context/prompt-policy configuration globally or in the current project's .pi/settings.json",
+                currentValue: this.scope,
+                values: ["global", "project"],
+            },
+            {
+                id: "context-policy-enabled",
+                label: "Prompt policy enforcement",
+                description: "Opt-in: stub stale artifact-backed grep/find output in the model-visible prompt only. Never touches transcript/session history. Requires the artifact_retrieve tool to be active this turn (not configurable here -- it's a runtime fact, not a setting).",
+                currentValue: booleanSettingValue(this.state.enabled, CONTEXT_POLICY_ENFORCEMENT_DEFAULTS.enabled),
+                values: ["false", "true"],
+            },
+            {
+                id: "context-policy-preserve-recent-messages",
+                label: "Preserve recent messages",
+                description: "Never stub a tool result within this many of the most recent messages",
+                currentValue: numberSettingValue(this.state.preserveRecentMessages, CONTEXT_POLICY_ENFORCEMENT_DEFAULTS.preserveRecentMessages),
+                values: CONTEXT_POLICY_PRESERVE_RECENT_MESSAGES_VALUES,
+            },
+            {
+                id: "context-policy-min-chars",
+                label: "Minimum chars before stubbing",
+                description: "Only stub a tool result whose original provider-visible text is at least this many characters",
+                currentValue: numberSettingValue(this.state.minChars, CONTEXT_POLICY_ENFORCEMENT_DEFAULTS.minChars),
+                values: CONTEXT_POLICY_MIN_CHARS_VALUES,
+            },
+        ];
+        this.settingsList = new SettingsList(items, Math.min(items.length, 10), getSettingsListTheme(), (id, newValue) => {
+            switch (id) {
+                case "context-policy-scope":
+                    this.scope = newValue;
+                    break;
+                case "context-policy-enabled":
+                    this.state = { ...this.state, enabled: newValue === "true" };
+                    break;
+                case "context-policy-preserve-recent-messages":
+                    this.state = { ...this.state, preserveRecentMessages: parseInt(newValue, 10) };
+                    break;
+                case "context-policy-min-chars":
+                    this.state = { ...this.state, minChars: parseInt(newValue, 10) };
+                    break;
+                default:
+                    return;
+            }
+            onChange({ ...this.state }, this.scope);
+        }, onCancel);
+        this.addChild(this.settingsList);
+    }
+    handleInput(data) {
+        this.settingsList.handleInput(data);
+    }
+}
+class ContextMemoryRetrievalSettingsSubmenu extends Container {
+    settingsList;
+    state;
+    scope;
+    constructor(settings, onChange, onCancel, scope = "global") {
+        super();
+        this.state = { ...settings };
+        this.scope = scope;
+        const items = [
+            {
+                id: "context-memory-scope",
+                label: "Save scope",
+                description: "Save this local memory-retrieval configuration globally or in the current project's .pi/settings.json",
+                currentValue: this.scope,
+                values: ["global", "project"],
+            },
+            {
+                id: "context-memory-enabled",
+                label: "Local memory retrieval",
+                description: "Opt-in: each turn, search local Pi OKF memory documents (under <agent dir>/okf-memory) for evidence related to the latest message. By default this is observe-only (recorded for inspection only). Enable 'Include in prompt' below to also surface a bounded, source-labeled evidence block to the model. Local-only; never queries an external provider.",
+                currentValue: booleanSettingValue(this.state.enabled, CONTEXT_MEMORY_RETRIEVAL_DEFAULTS.enabled),
+                values: ["false", "true"],
+            },
+            {
+                id: "context-memory-max-results",
+                label: "Max results",
+                description: "Maximum number of memory items to retrieve per query (1-20)",
+                currentValue: numberSettingValue(this.state.maxResults, CONTEXT_MEMORY_RETRIEVAL_DEFAULTS.maxResults),
+                values: CONTEXT_MEMORY_RETRIEVAL_MAX_RESULTS_VALUES,
+            },
+            {
+                id: "context-memory-include-in-prompt",
+                label: "Include in prompt",
+                description: "Opt-in, requires 'Local memory retrieval' enabled above: surfaces retrieved memory as a bounded, source-labeled, untrusted-evidence block in the model prompt only -- never the transcript, never treated as an instruction or rule. Default off.",
+                currentValue: booleanSettingValue(this.state.includeInPrompt, CONTEXT_MEMORY_RETRIEVAL_DEFAULTS.includeInPrompt),
+                values: ["false", "true"],
+            },
+        ];
+        this.settingsList = new SettingsList(items, Math.min(items.length, 10), getSettingsListTheme(), (id, newValue) => {
+            switch (id) {
+                case "context-memory-scope":
+                    this.scope = newValue;
+                    break;
+                case "context-memory-enabled":
+                    this.state = { ...this.state, enabled: newValue === "true" };
+                    break;
+                case "context-memory-max-results":
+                    this.state = { ...this.state, maxResults: parseInt(newValue, 10) };
+                    break;
+                case "context-memory-include-in-prompt":
+                    this.state = { ...this.state, includeInPrompt: newValue === "true" };
+                    break;
+                default:
+                    return;
+            }
+            onChange({ ...this.state }, this.scope);
+        }, onCancel);
+        this.addChild(this.settingsList);
+    }
+    handleInput(data) {
+        this.settingsList.handleInput(data);
+    }
+}
 class ModelRouterSettingsSubmenu extends Container {
     settingsList;
     state;
@@ -519,6 +980,13 @@ class ModelRouterSettingsSubmenu extends Container {
             includeActive: false,
             unsetDescription: "Clear cheap routing model; research turns fall back to the active session model",
         });
+        const mediumModelOptions = buildModelRouterRoleModelOptions({
+            currentValue: this.state.mediumModel,
+            configuredModelOptions: modelOptions,
+            currentModelPattern,
+            includeActive: false,
+            unsetDescription: "Clear medium routing model; implementation turns fall back according to router policy",
+        });
         const expensiveModelOptions = buildModelRouterRoleModelOptions({
             currentValue: this.state.expensiveModel,
             configuredModelOptions: modelOptions,
@@ -570,6 +1038,27 @@ class ModelRouterSettingsSubmenu extends Container {
                     customEmptyValue: MODEL_ROUTER_UNSET_MODEL_VALUE,
                 }),
             },
+            {
+                id: "model-router-medium",
+                label: "Medium model",
+                description: "Pick the model for normal scoped implementation, edits, tests, and mechanical refactors",
+                currentValue: optionalStringValue(this.state.mediumModel),
+                submenu: (_currentValue, done) => new ModelSelectionSubmenu(mediumModelOptions, this.state.mediumModel ?? MODEL_ROUTER_UNSET_MODEL_VALUE, (value) => {
+                    this.state = {
+                        ...this.state,
+                        mediumModel: value === MODEL_ROUTER_UNSET_MODEL_VALUE ? undefined : value,
+                    };
+                    onChange({ ...this.state }, this.scope);
+                    done(optionalStringValue(this.state.mediumModel));
+                }, () => done(), {
+                    title: "Medium / Implementation Model",
+                    description: "Choose from models available through configured subscription/API accounts. Type to filter; manual is fallback.",
+                    customTitle: "Custom Medium / Implementation Model",
+                    customDescription: "Enter a provider/model pattern from pi --list-models.",
+                    customEmptyHint: "empty clears the setting",
+                    customEmptyValue: MODEL_ROUTER_UNSET_MODEL_VALUE,
+                }),
+            },
             {
                 id: "model-router-expensive",
                 label: "Expensive model",
@@ -719,8 +1208,13 @@ export class SettingsSelectorComponent extends Container {
         let currentWarnings = { ...config.warnings };
         let currentSelfModification = { ...config.selfModification };
         let currentAutonomy = { ...config.autonomy };
+        let currentResearchLane = { ...config.researchLane };
+        let currentContextCuration = { ...config.contextCuration };
+        let currentWorkerDelegation = { ...config.workerDelegation };
         let currentModelRouter = { ...config.modelRouter };
         let currentAutoLearn = { ...config.autoLearn };
+        let currentContextPolicyEnforcement = { ...config.contextPolicyEnforcement };
+        let currentContextMemoryRetrieval = { ...config.contextMemoryRetrieval };
         const items = [
             {
                 id: "autocompact",
@@ -819,6 +1313,36 @@ export class SettingsSelectorComponent extends Container {
                     callbacks.onAutonomyChange(settings, scope);
                 }, () => done(autonomySummary(currentAutonomy)), config.autonomyScope ?? "global"),
             },
+            {
+                id: "research-lane",
+                label: "Research Lane",
+                description: "Opt-in autonomous read-only research: bounded background passes that produce evidence bundles for active goals",
+                currentValue: researchLaneSummary(currentResearchLane),
+                submenu: (_currentValue, done) => new ResearchLaneSettingsSubmenu(currentResearchLane, (settings, scope) => {
+                    currentResearchLane = { ...settings };
+                    callbacks.onResearchLaneChange(settings, scope);
+                }, () => done(researchLaneSummary(currentResearchLane)), config.researchLaneScope ?? "global"),
+            },
+            {
+                id: "worker-delegation",
+                label: "Worker Delegation",
+                description: "Opt-in bounded scout-worker delegation: the delegate tool runs read-only workers on a cheap model lane",
+                currentValue: workerDelegationSummary(currentWorkerDelegation),
+                submenu: (_currentValue, done) => new WorkerDelegationSettingsSubmenu(currentWorkerDelegation, (settings, scope) => {
+                    currentWorkerDelegation = { ...settings };
+                    callbacks.onWorkerDelegationChange(settings, scope);
+                }, () => done(workerDelegationSummary(currentWorkerDelegation)), config.workerDelegationScope ?? "global"),
+            },
+            {
+                id: "context-curation",
+                label: "Context Curation",
+                description: "Opt-in local brain curator: digests GC-packed context stubs and scores stale-chunk relevance in small local-model jobs",
+                currentValue: contextCurationSummary(currentContextCuration),
+                submenu: (_currentValue, done) => new ContextCurationSettingsSubmenu(currentContextCuration, config.autoLearnModelOptions, (settings, scope) => {
+                    currentContextCuration = { ...settings };
+                    callbacks.onContextCurationChange(settings, scope);
+                }, () => done(contextCurationSummary(currentContextCuration)), config.contextCurationScope ?? "global"),
+            },
             {
                 id: "model-router",
                 label: "Model Router",
@@ -839,6 +1363,26 @@ export class SettingsSelectorComponent extends Container {
                     callbacks.onAutoLearnChange(settings, scope);
                 }, () => done(autoLearnSummary(currentAutoLearn)), config.autoLearnScope ?? "global"),
             },
+            {
+                id: "context-policy-enforcement",
+                label: "Context / Prompt Policy",
+                description: "Opt-in artifact-stub prompt-policy enforcement: stubs stale artifact-backed tool output in the model-visible prompt only, never the transcript. Requires the artifact_retrieve tool to be active.",
+                currentValue: contextPolicyEnforcementSummary(currentContextPolicyEnforcement),
+                submenu: (_currentValue, done) => new ContextPolicyEnforcementSettingsSubmenu(currentContextPolicyEnforcement, (settings, scope) => {
+                    currentContextPolicyEnforcement = { ...settings };
+                    callbacks.onContextPolicyEnforcementChange(settings, scope);
+                }, () => done(contextPolicyEnforcementSummary(currentContextPolicyEnforcement)), config.contextPolicyEnforcementScope ?? "global"),
+            },
+            {
+                id: "context-memory-retrieval",
+                label: "Context / Memory Retrieval",
+                description: "Opt-in local memory retrieval: searches local Pi OKF memory documents each turn and records source-labeled evidence for inspection. Prompt inclusion is off by default and only occurs when 'Include in prompt' is enabled. Never queries an external provider.",
+                currentValue: contextMemoryRetrievalSummary(currentContextMemoryRetrieval),
+                submenu: (_currentValue, done) => new ContextMemoryRetrievalSettingsSubmenu(currentContextMemoryRetrieval, (settings, scope) => {
+                    currentContextMemoryRetrieval = { ...settings };
+                    callbacks.onContextMemoryRetrievalChange(settings, scope);
+                }, () => done(contextMemoryRetrievalSummary(currentContextMemoryRetrieval)), config.contextMemoryRetrievalScope ?? "global"),
+            },
             {
                 id: "warnings",
                 label: "Warnings",