@signalridge/pi-goal 1.4.8 → 1.5.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # @signalridge/pi-goal
 
+## 1.5.0
+### Minor Changes
+
+- 4697441: Add `experimental.notices`, a setting beside `experimental.goals` that silences the session-start notice announcing the experimental ordered-goal queue. It defaults to `true`, so existing sessions report exactly as before, and it suppresses only that announcement: validation failures, settings-load warnings, and recovery notices still report because they describe a problem rather than restate a choice the user already made. The queue, its subcommands, and `queue off` freezing are unaffected, and the Settings menu exposes the new control directly under **Ordered goal queue**.
+
 ## 1.4.8
 ### Patch Changes
 

package/README.md

@@ -61,7 +61,8 @@ built-in defaults without creating the file:
 {
   "toolVisibility": "after-first-goal",
   "experimental": {
-    "goals": false
+    "goals": false,
+    "notices": true
   },
   "rpc": {
     "enabled": false
@@ -74,13 +75,14 @@ built-in defaults without creating the file:
 ```
 
 Use `/goal` → **Settings…** in the TUI to create or update the file interactively, or create
-and edit it directly. The standard Settings screen keeps all five controls on one level in task
+and edit it directly. The standard Settings screen keeps all six controls on one level in task
 order; the two safety limits open standard choice screens:
 
 - **Automatic-work limit** shows the exact response limit or **Unlimited**. Choose **Set response limit…** to edit the current finite value (or the built-in default of 25 when switching from Unlimited), or choose **Unlimited…**. Unlimited requires confirmation that tool loops may continue consuming tokens and provider cost without a response-count cap.
 - **No-progress guard** shows **_N_ runs** or **Off**. Choose the default threshold, **Off**, or **Set threshold…** and enter a safe whole number greater than zero.
 - **Goal tools** controls whether terminal Goal tools are always visible or appear after the first goal.
 - **Ordered goal queue** controls the experimental ordered-goal workflows.
+- **Experimental notice** controls whether a session reports once that experimental behavior and persisted state may change. It defaults to **On** and suppresses only that announcement; the queue itself is unaffected.
 - **Managed run RPC** controls whether trusted installed extensions may start and cancel managed Goal runs. It defaults to **Off** and is a cooperation setting, not an extension security sandbox.
 
 Custom number inputs reject zero, negative numbers, decimals, text, and unsafe integers without saving; use the explicit **Unlimited** or **Off** choice instead. Interactive changes are serialized, written atomically, preserve unknown fields, and apply to the current runtime. A successful change updates the visible state immediately. A failed save restores the prior value and reports the settings path so it can be retried. Tool-visibility changes that would alter the active tool schema are rejected while Pi is busy; retry after Pi settles. Escape returns to the previous screen without reverting changes that were already saved.
@@ -92,6 +94,8 @@ Custom number inputs reject zero, negative numbers, decimals, text, and unsafe i
 
 `experimental.goals` accepts a boolean and defaults to `false`. Set it to `true` to enable the ordered-goal subcommands and automatic queue advancement described below. Enabled sessions show one warning because command behavior and persisted queue state remain experimental.
 
+`experimental.notices` accepts a boolean and defaults to `true`. It controls that single experimental-goals announcement: with `notices: false` a session starts without it, while the queue, its subcommands, and queue freezing behave exactly as they do with `notices: true`. Nothing else routes through this setting — validation failures, settings-load warnings, and recovery notices always report, because those describe a problem rather than restate a choice the user has already made. Use it when the experiment is a standing configuration rather than a trial, so the warning level keeps meaning something.
+
 `rpc.enabled` accepts a boolean and defaults to `false`. When disabled, a valid managed-run start receives `RPC_DISABLED`; manual and restored Goals remain unchanged. A Settings-menu change applies immediately after its atomic save. Disabling rejects new starts but lets an already accepted run continue publishing its exact state and accept its exact cancellation until terminal, avoiding stranded work. Reload, replacement, and shutdown clear that in-memory ownership.
 
 `continuationLimits` controls the runaway guards:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalridge/pi-goal",
-  "version": "1.4.8",
+  "version": "1.5.0",
   "description": "Pi extension for autonomous /goal completion with opt-in experimental ordered queues.",
   "type": "module",
   "license": "MIT",

package/src/lifecycle.ts

@@ -106,7 +106,7 @@ export function registerGoalLifecycle(
     if (settingsResult.kind === "invalid") {
       notifyTerminal(ctx.ui, `pi-goal settings ignored: ${settingsResult.reason}. Using default settings.`, "warning");
     }
-    if (runtime.settings.experimental.goals) {
+    if (runtime.settings.experimental.goals && runtime.settings.experimental.notices) {
       notifyTerminal(ctx.ui, EXPERIMENTAL_GOALS_WARNING, "warning");
     }
     try {

package/src/settings-ui.ts

@@ -43,6 +43,7 @@ export async function showGoalSettings(
     | "choose-no-progress"
     | "set-visibility"
     | "set-queue"
+    | "set-notices"
     | "set-rpc";
   const menu = defineMenu<undefined, Screen, Action, ExtensionCommandContext>({
     start: invalid ? "invalid" : (options.initialScreen ?? "settings"),
@@ -82,6 +83,14 @@ export async function showGoalSettings(
             values: ["Off", "Experimental"],
             action: "set-queue",
           },
+          {
+            id: "experimentalNotices",
+            label: "Experimental notice",
+            description: "Say once per session that experimental behavior and persisted state may change.",
+            currentValue: runtime.settings.experimental.notices ? "On" : "Off",
+            values: ["On", "Off"],
+            action: "set-notices",
+          },
           {
             id: "rpcEnabled",
             label: "Managed run RPC",
@@ -104,6 +113,7 @@ export async function showGoalSettings(
           `No-progress guard: ${formatNoProgressProtection(runtime.settings.continuationLimits.noProgressTurns)}`,
           `Goal tools: ${visibilityLabel(runtime.settings.toolVisibility)}`,
           `Ordered goal queue: ${runtime.settings.experimental.goals ? "Experimental" : "Off"}`,
+          `Experimental notice: ${runtime.settings.experimental.notices ? "On" : "Off"}`,
           `Managed run RPC: ${runtime.settings.rpc.enabled ? "On" : "Off"}`,
         ],
         hint: "back",
@@ -186,6 +196,24 @@ export async function showGoalSettings(
           return { kind: "rejected" };
         }
       },
+      "set-notices": async ({ value }) => {
+        const enabled = value === "On";
+        if (enabled === runtime.settings.experimental.notices) return { kind: "stay" };
+        try {
+          const next = {
+            ...structuredClone(runtime.settings),
+            experimental: { ...runtime.settings.experimental, notices: enabled },
+          } satisfies GoalSettings;
+          applyGoalSettings(runtime, next, ctx, {
+            save: (settings) => (options.save ?? saveGoalSettings)(settings, settingsPath),
+          });
+          notifyTerminal(ctx.ui, `Experimental notice: ${enabled ? "On" : "Off"}.`, "info");
+          return { kind: "stay" };
+        } catch (error) {
+          notifySettingsFailure(ctx, settingsPath, error);
+          return { kind: "rejected" };
+        }
+      },
       "set-rpc": async ({ value }) => {
         const enabled = value === "On";
         if (enabled === runtime.settings.rpc.enabled) return { kind: "stay" };
@@ -459,7 +487,7 @@ async function nextQueueSettings(runtime: GoalRuntime, ctx: ExtensionCommandCont
   }
   return {
     ...structuredClone(runtime.settings),
-    experimental: { goals: enabled },
+    experimental: { ...runtime.settings.experimental, goals: enabled },
   } satisfies GoalSettings;
 }
 

package/src/settings.ts

@@ -13,6 +13,7 @@ export interface GoalSettings {
   toolVisibility: GoalToolVisibility;
   experimental: {
     goals: boolean;
+    notices: boolean;
   };
   rpc: {
     enabled: boolean;
@@ -32,7 +33,12 @@ export const DEFAULT_GOAL_SETTINGS: GoalSettings = {
   // unfinished goal reveals them at startup. Set `"always"` to keep them
   // resident.
   toolVisibility: "after-first-goal",
-  experimental: { goals: false },
+  // `notices` is on by default: a user who enabled an experiment should be told
+  // once per session that its persisted state may change. It exists so that
+  // acknowledgement is a setting rather than a repeated prompt — a warning the
+  // reader cannot accept stops carrying information, and the same notification
+  // level carries failures worth reading.
+  experimental: { goals: false, notices: true },
   rpc: { enabled: false },
   continuationLimits: { automaticTurns: 25, noProgressTurns: 3 },
 };
@@ -70,6 +76,11 @@ export function normalizeGoalSettings(value: unknown): GoalSettings | undefined
       ? Reflect.get(experimentalValue, "goals")
       : DEFAULT_GOAL_SETTINGS.experimental.goals;
   if (typeof goals !== "boolean") return undefined;
+  const notices =
+    experimentalValue && Object.hasOwn(experimentalValue, "notices")
+      ? Reflect.get(experimentalValue, "notices")
+      : DEFAULT_GOAL_SETTINGS.experimental.notices;
+  if (typeof notices !== "boolean") return undefined;
 
   const rpcValue = Object.hasOwn(value, "rpc") ? Reflect.get(value, "rpc") : undefined;
   if (rpcValue !== undefined && (typeof rpcValue !== "object" || rpcValue === null || Array.isArray(rpcValue))) {
@@ -108,7 +119,7 @@ export function normalizeGoalSettings(value: unknown): GoalSettings | undefined
 
   return {
     toolVisibility: toolVisibility as GoalToolVisibility,
-    experimental: { goals },
+    experimental: { goals, notices },
     rpc: { enabled: rpcEnabled },
     continuationLimits: { automaticTurns, noProgressTurns },
   };
@@ -149,7 +160,11 @@ export function saveGoalSettings(
     {
       ...raw,
       toolVisibility: normalized.toolVisibility,
-      experimental: { ...experimental, goals: normalized.experimental.goals },
+      experimental: {
+        ...experimental,
+        goals: normalized.experimental.goals,
+        notices: normalized.experimental.notices,
+      },
       rpc: { ...rpc, enabled: normalized.rpc.enabled },
       continuationLimits: {
         ...continuationLimits,