@bilalimamoglu/sift 0.4.4 → 0.4.5

package/dist/cli.js

@@ -109,6 +109,7 @@ var defaultConfig = {
     tailChars: 2e4
   },
   runtime: {
+    operationMode: "agent-escalation",
     rawFallback: true,
     verbose: false
   },
@@ -158,12 +159,62 @@ var defaultConfig = {
   }
 };
 
+// src/config/provider-models.ts
+var OPENAI_MODELS = [
+  {
+    model: "gpt-5-nano",
+    label: "gpt-5-nano",
+    note: "default, cheapest, fast enough for most fallback passes",
+    isDefault: true
+  },
+  {
+    model: "gpt-5.4-nano",
+    label: "gpt-5.4-nano",
+    note: "newer nano backup, a touch smarter, a touch pricier"
+  },
+  {
+    model: "gpt-5-mini",
+    label: "gpt-5-mini",
+    note: "smarter fallback, still saner than the expensive stuff"
+  }
+];
+var OPENROUTER_MODELS = [
+  {
+    model: "openrouter/free",
+    label: "openrouter/free",
+    note: "default, free, a little slower sometimes, still hard to argue with free",
+    isDefault: true
+  },
+  {
+    model: "qwen/qwen3-coder:free",
+    label: "qwen/qwen3-coder:free",
+    note: "free, code-focused, good when you want a named coding fallback"
+  },
+  {
+    model: "deepseek/deepseek-r1:free",
+    label: "deepseek/deepseek-r1:free",
+    note: "free, stronger reasoning, usually slower"
+  }
+];
+function getProviderModelOptions(provider) {
+  return provider === "openrouter" ? OPENROUTER_MODELS : OPENAI_MODELS;
+}
+function getDefaultProviderModel(provider) {
+  return getProviderModelOptions(provider).find((option) => option.isDefault)?.model ?? getProviderModelOptions(provider)[0]?.model ?? "";
+}
+function findProviderModelOption(provider, model) {
+  if (!model) {
+    return void 0;
+  }
+  return getProviderModelOptions(provider).find((option) => option.model === model);
+}
+
 // src/config/native-provider.ts
 function getNativeProviderDefaults(provider) {
   if (provider === "openrouter") {
     return {
       provider,
-      model: "openrouter/free",
+      model: getDefaultProviderModel("openrouter"),
       baseUrl: "https://openrouter.ai/api/v1"
     };
   }
@@ -305,6 +356,11 @@ function getProviderApiKeyEnvNames(provider, baseUrl) {
 
 // src/config/schema.ts
 import { z } from "zod";
+var operationModeSchema = z.enum([
+  "agent-escalation",
+  "provider-assisted",
+  "local-only"
+]);
 var providerNameSchema = z.enum([
   "openai",
   "openai-compatible",
@@ -357,6 +413,7 @@ var inputConfigSchema = z.object({
   tailChars: z.number().int().positive()
 });
 var runtimeConfigSchema = z.object({
+  operationMode: operationModeSchema,
   rawFallback: z.boolean(),
   verbose: z.boolean()
 });
@@ -379,7 +436,7 @@ var siftConfigSchema = z.object({
 var PROVIDER_DEFAULT_OVERRIDES = {
   openrouter: {
     provider: {
-      model: "openrouter/free",
+      model: getDefaultProviderModel("openrouter"),
       baseUrl: "https://openrouter.ai/api/v1"
     }
   }
@@ -419,13 +476,16 @@ function stripApiKey(overrides) {
 }
 function buildNonCredentialEnvOverrides(env) {
   const overrides = {};
-  if (env.SIFT_PROVIDER || env.SIFT_MODEL || env.SIFT_BASE_URL || env.SIFT_TIMEOUT_MS) {
+  if (env.SIFT_PROVIDER || env.SIFT_MODEL || env.SIFT_BASE_URL || env.SIFT_TIMEOUT_MS || env.SIFT_OPERATION_MODE) {
     overrides.provider = {
       provider: env.SIFT_PROVIDER,
       model: env.SIFT_MODEL,
       baseUrl: env.SIFT_BASE_URL,
       timeoutMs: env.SIFT_TIMEOUT_MS ? Number(env.SIFT_TIMEOUT_MS) : void 0
     };
+    overrides.runtime = {
+      operationMode: env.SIFT_OPERATION_MODE
+    };
   }
   if (env.SIFT_MAX_INPUT_CHARS || env.SIFT_MAX_CAPTURE_CHARS) {
     overrides.input = {
@@ -492,6 +552,15 @@ function resolveConfig(options = {}) {
   );
   return siftConfigSchema.parse(merged);
 }
+function hasUsableProvider(config) {
+  return config.provider.apiKey !== void 0 && config.provider.apiKey.trim().length > 0;
+}
+function resolveEffectiveOperationMode(config) {
+  if (config.runtime.operationMode === "provider-assisted") {
+    return hasUsableProvider(config) ? "provider-assisted" : "agent-escalation";
+  }
+  return config.runtime.operationMode;
+}
 
 // src/config/write.ts
 import fs3 from "fs";
@@ -616,10 +685,129 @@ import { emitKeypressEvents } from "readline";
 import { createInterface } from "readline/promises";
 import { stderr as defaultStderr, stdin as defaultStdin2, stdout as defaultStdout } from "process";
 
+// src/config/operation-mode.ts
+function getOperationModeLabel(mode) {
+  switch (mode) {
+    case "agent-escalation":
+      return "Agent escalation";
+    case "provider-assisted":
+      return "Provider-assisted";
+    case "local-only":
+      return "Local-only";
+  }
+}
+function describeOperationMode(mode) {
+  switch (mode) {
+    case "agent-escalation":
+      return "Best when you already have an agent open. sift does the quick first pass, then the agent can read code, tests, or logs and keep going.";
+    case "provider-assisted":
+      return "Best when you want sift itself to take one more cheap swing at the problem before you fall back to an agent or raw logs. Built-in rules first, API-backed backup second.";
+    case "local-only":
+      return "Best when you are not pairing sift with another agent and do not want API keys. Everything stays local.";
+  }
+}
+function describeInsufficientBehavior(mode) {
+  switch (mode) {
+    case "agent-escalation":
+      return "If sift is still not enough, that is the handoff point: log it, narrow the problem, and let the agent keep digging.";
+    case "provider-assisted":
+      return "If the first pass is still fuzzy, sift can ask the fallback model so you do not have to escalate every annoying edge case by hand.";
+    case "local-only":
+      return "If sift is still not enough, stay local: rerun something narrower, use a better preset, or read the relevant source and tests yourself.";
+  }
+}
+
 // src/ui/terminal.ts
 import { execFileSync } from "child_process";
 import { clearScreenDown, cursorTo, moveCursor } from "readline";
 import { stdin as defaultStdin } from "process";
+var PROMPT_BACK = "__sift_back__";
+var PROMPT_BACK_LABEL = "\u2190 Back";
+function color(text, rgb, args = {}) {
+  const codes = [];
+  if (args.bold) {
+    codes.push("1");
+  }
+  if (args.dim) {
+    codes.push("2");
+  }
+  codes.push(`38;2;${rgb[0]};${rgb[1]};${rgb[2]}`);
+  return `\x1B[${codes.join(";")}m${text}\x1B[0m`;
+}
+function splitOptionLeading(option) {
+  const boundaries = [" - ", ": ", ":", " ("].map((token) => {
+    const index = option.indexOf(token);
+    return index >= 0 ? { index, token } : void 0;
+  }).filter((entry) => Boolean(entry)).sort((left, right) => left.index - right.index);
+  const boundary = boundaries[0];
+  if (!boundary) {
+    return { leading: option, trailing: "" };
+  }
+  return {
+    leading: option.slice(0, boundary.index),
+    trailing: option.slice(boundary.index)
+  };
+}
+function getOptionPalette(leading) {
+  const normalized = leading.trim();
+  if (normalized.startsWith("With an agent")) {
+    return { rgb: [214, 168, 76] };
+  }
+  if (normalized.startsWith("With provider fallback")) {
+    return { rgb: [100, 141, 214] };
+  }
+  if (normalized.startsWith("Solo, local-only")) {
+    return { rgb: [122, 142, 116], dimWhenIdle: true };
+  }
+  if (normalized.startsWith("Codex")) {
+    return { rgb: [233, 183, 78] };
+  }
+  if (normalized.startsWith("Claude")) {
+    return { rgb: [171, 138, 224] };
+  }
+  if (normalized === "All") {
+    return { rgb: [95, 181, 201] };
+  }
+  if (normalized.startsWith("Global")) {
+    return { rgb: [205, 168, 83] };
+  }
+  if (normalized.startsWith("Local")) {
+    return { rgb: [138, 144, 150], dimWhenIdle: true };
+  }
+  if (normalized.startsWith("OpenAI")) {
+    return { rgb: [82, 177, 124] };
+  }
+  if (normalized.startsWith("OpenRouter")) {
+    return { rgb: [106, 144, 221] };
+  }
+  if (normalized.startsWith("Use saved key") || normalized.startsWith("Use existing key")) {
+    return { rgb: [111, 181, 123] };
+  }
+  if (normalized.startsWith("Use environment key")) {
+    return { rgb: [102, 146, 219] };
+  }
+  if (normalized.startsWith("Enter a different key") || normalized.startsWith("Custom model")) {
+    return { rgb: [191, 157, 92], dimWhenIdle: true };
+  }
+  return void 0;
+}
+function styleOption(option, selected, colorize) {
+  if (!colorize) {
+    return option;
+  }
+  if (option === PROMPT_BACK_LABEL) {
+    return color(option, [164, 169, 178], { bold: selected, dim: !selected });
+  }
+  const { leading, trailing } = splitOptionLeading(option);
+  const palette = getOptionPalette(leading);
+  if (!palette) {
+    return option;
+  }
+  return `${color(leading, palette.rgb, {
+    bold: selected,
+    dim: !selected && Boolean(palette.dimWhenIdle)
+  })}${trailing}`;
+}
 function setPosixEcho(enabled) {
   const command = enabled ? "echo" : "-echo";
   try {
@@ -637,10 +825,15 @@ function setPosixEcho(enabled) {
   }
 }
 function renderSelectionBlock(args) {
+  const options = args.allowBack ? [...args.options, args.backLabel ?? PROMPT_BACK_LABEL] : args.options;
   return [
-    `${args.prompt} (use \u2191/\u2193 and Enter)`,
-    ...args.options.map(
-      (option, index) => `${index === args.selectedIndex ? "\u203A" : " "} ${option}${index === args.selectedIndex ? " (selected)" : ""}`
+    `${args.prompt}${args.allowBack ? " (use \u2191/\u2193 to move, Enter to select, Esc to go back)" : " (use \u2191/\u2193 and Enter)"}`,
+    ...options.map(
+      (option, index) => `${index === args.selectedIndex ? "\u203A" : " "} ${styleOption(
+        option,
+        index === args.selectedIndex,
+        Boolean(args.colorize)
+      )}${index === args.selectedIndex ? " (selected)" : ""}`
     )
   ];
 }
@@ -648,6 +841,8 @@ async function promptSelect(args) {
   const { input, output, prompt, options } = args;
   const stream = output;
   const selectedLabel = args.selectedLabel ?? prompt;
+  const backLabel = args.backLabel ?? PROMPT_BACK_LABEL;
+  const allOptions = args.allowBack ? [...options, backLabel] : options;
   let index = 0;
   let previousLineCount = 0;
   const render = () => {
@@ -659,7 +854,10 @@ async function promptSelect(args) {
     const lines = renderSelectionBlock({
       prompt,
       options,
-      selectedIndex: index
+      selectedIndex: index,
+      allowBack: args.allowBack,
+      backLabel,
+      colorize: Boolean(stream?.isTTY)
     });
     output.write(`${lines.join("\n")}
 `);
@@ -691,22 +889,30 @@ async function promptSelect(args) {
         return;
       }
       if (key.name === "up") {
-        index = index === 0 ? options.length - 1 : index - 1;
+        index = index === 0 ? allOptions.length - 1 : index - 1;
         render();
         return;
       }
       if (key.name === "down") {
-        index = (index + 1) % options.length;
+        index = (index + 1) % allOptions.length;
         render();
         return;
       }
+      if (args.allowBack && key.name === "escape") {
+        input.off("keypress", onKeypress);
+        cleanup();
+        input.setRawMode?.(wasRaw);
+        input.pause?.();
+        resolve(PROMPT_BACK);
+        return;
+      }
       if (key.name === "return" || key.name === "enter") {
-        const selected = options[index] ?? options[0] ?? "";
+        const selected = allOptions[index] ?? allOptions[0] ?? "";
         input.off("keypress", onKeypress);
-        cleanup(selected);
+        cleanup(selected === backLabel ? void 0 : selected);
         input.setRawMode?.(wasRaw);
         input.pause?.();
-        resolve(selected);
+        resolve(selected === backLabel ? PROMPT_BACK : selected);
       }
     };
     input.on("keypress", onKeypress);
@@ -739,6 +945,13 @@ async function promptSecret(args) {
         reject(new Error("Aborted."));
         return;
       }
+      if (args.allowBack && key.name === "escape") {
+        input.off("keypress", onKeypress);
+        restoreInputState();
+        output.write("\n");
+        resolve(PROMPT_BACK);
+        return;
+      }
       if (key.name === "return" || key.name === "enter") {
         input.off("keypress", onKeypress);
         restoreInputState();
@@ -759,6 +972,7 @@ async function promptSecret(args) {
 }
 
 // src/commands/config-setup.ts
+var CONFIG_SETUP_BACK = 2;
 function createTerminalIO() {
   let rl;
   function getInterface() {
@@ -771,22 +985,24 @@ function createTerminalIO() {
     }
     return rl;
   }
-  async function select(prompt, options) {
+  async function select(prompt, options, selectedLabel, allowBack) {
     emitKeypressEvents(defaultStdin2);
     return await promptSelect({
       input: defaultStdin2,
       output: defaultStdout,
       prompt,
       options,
-      selectedLabel: "Provider"
+      selectedLabel,
+      allowBack
     });
   }
-  async function secret(prompt) {
+  async function secret(prompt, allowBack) {
     emitKeypressEvents(defaultStdin2);
     return await promptSecret({
       input: defaultStdin2,
       output: defaultStdout,
-      prompt
+      prompt,
+      allowBack
     });
   }
   return {
@@ -817,12 +1033,58 @@ function getSetupPresenter(io) {
 function getProviderLabel(provider) {
   return provider === "openrouter" ? "OpenRouter" : "OpenAI";
 }
+function isBackSelection(value) {
+  return value === PROMPT_BACK || value === PROMPT_BACK_LABEL;
+}
+async function promptForOperationMode(io) {
+  if (io.select) {
+    const choice = await io.select(
+      "Choose how sift should work",
+      [
+        "With an agent: recommended if Codex or Claude is already with you; sift does the fast local first pass, the agent only steps in when repo context is truly needed",
+        "With provider fallback: recommended if you want sift to finish more ambiguous cases on its own before handing them back to you or your agent; requires an API key, cheap model only when needed",
+        "Solo, local-only: recommended if you want zero model calls; great for supported presets, ambiguous cases stay with you"
+      ],
+      "Mode"
+    );
+    if (choice.startsWith("With an agent")) {
+      return "agent-escalation";
+    }
+    if (choice.startsWith("With provider fallback")) {
+      return "provider-assisted";
+    }
+    if (choice.startsWith("Solo, local-only")) {
+      return "local-only";
+    }
+  }
+  while (true) {
+    const answer = (await io.ask("Use style [agent/provider/local]: ")).trim().toLowerCase();
+    if (answer === "" || answer === "agent" || answer === "agent-escalation") {
+      return "agent-escalation";
+    }
+    if (answer === "provider" || answer === "provider-assisted") {
+      return "provider-assisted";
+    }
+    if (answer === "local" || answer === "local-only") {
+      return "local-only";
+    }
+    io.error("Please answer agent, provider, or local.\n");
+  }
+}
 async function promptForProvider(io) {
   if (io.select) {
-    const choice = await io.select("Select provider for this machine", [
-      "OpenAI",
-      "OpenRouter"
-    ]);
+    const choice = await io.select(
+      "Okay, whose API key are we borrowing for fallback duty?",
+      [
+        "OpenAI",
+        "OpenRouter"
+      ],
+      "Provider",
+      true
+    );
+    if (isBackSelection(choice)) {
+      return PROMPT_BACK;
+    }
     if (choice === "OpenAI") {
       return "openai";
     }
@@ -832,6 +1094,9 @@ async function promptForProvider(io) {
   }
   while (true) {
     const answer = (await io.ask("Provider [OpenAI/OpenRouter]: ")).trim().toLowerCase();
+    if (answer === "back" || answer === "b") {
+      return PROMPT_BACK;
+    }
     if (answer === "" || answer === "openai") {
       return "openai";
     }
@@ -846,7 +1111,13 @@ async function promptForApiKey(io, provider) {
   const promptText = `Enter your ${providerLabel} API key (input hidden): `;
   const visiblePromptText = `Enter your ${providerLabel} API key: `;
   while (true) {
-    const answer = (await (io.secret ? io.secret(promptText) : io.ask(visiblePromptText))).trim();
+    const answer = (await (io.secret ? io.secret(promptText, true) : io.ask(visiblePromptText))).trim();
+    if (answer === PROMPT_BACK) {
+      return PROMPT_BACK;
+    }
+    if (!io.secret && (answer.toLowerCase() === "back" || answer.toLowerCase() === "b")) {
+      return PROMPT_BACK;
+    }
     if (answer.length > 0) {
       return answer;
     }
@@ -862,17 +1133,25 @@ async function promptForApiKeyChoice(args) {
     if (args.io.select) {
       const choice = await args.io.select(
         `Found both a saved ${providerLabel} API key and ${args.envName} in your environment`,
-        ["Use saved key", "Use env key", "Override"]
+        ["Use saved key", "Use environment key", "Enter a different key"],
+        "API key",
+        true
       );
+      if (isBackSelection(choice)) {
+        return PROMPT_BACK;
+      }
       if (choice === "Use saved key") {
         return "saved";
       }
-      if (choice === "Use env key") {
+      if (choice === "Use environment key") {
         return "env";
       }
     }
     while (true) {
       const answer = (await args.io.ask("API key choice [saved/env/override]: ")).trim().toLowerCase();
+      if (answer === "back" || answer === "b") {
+        return PROMPT_BACK;
+      }
       if (answer === "" || answer === "saved") {
         return "saved";
       }
@@ -889,15 +1168,23 @@ async function promptForApiKeyChoice(args) {
   if (args.io.select) {
     const choice = await args.io.select(
       `Found an existing ${providerLabel} API key via ${sourceLabel}`,
-      ["Use existing key", "Override"]
+      ["Use saved key", "Enter a different key"],
+      "API key",
+      true
     );
-    if (choice === "Override") {
+    if (isBackSelection(choice)) {
+      return PROMPT_BACK;
+    }
+    if (choice === "Enter a different key") {
       return "override";
     }
     return args.hasSavedKey ? "saved" : "env";
   }
   while (true) {
     const answer = (await args.io.ask("API key choice [existing/override]: ")).trim().toLowerCase();
+    if (answer === "back" || answer === "b") {
+      return PROMPT_BACK;
+    }
     if (answer === "" || answer === "existing") {
       return args.hasSavedKey ? "saved" : "env";
     }
@@ -907,12 +1194,41 @@ async function promptForApiKeyChoice(args) {
     args.io.error("Please answer existing or override.\n");
   }
 }
-function writeSetupSuccess(io, writtenPath) {
+function writeModeSummary(io, mode) {
+  const ui = getSetupPresenter(io);
+  io.write(`${ui.info(`Operating mode: ${getOperationModeLabel(mode)}`)}
+`);
+  io.write(`${ui.note(describeOperationMode(mode))}
+`);
+  io.write(`${ui.note(describeInsufficientBehavior(mode))}
+`);
+  if (mode === "agent-escalation") {
+    io.write(
+      `${ui.note("Plain English: pick this if you already use Codex or Claude. sift gives the first answer; the agent only steps in when deeper repo context is really needed. No API key.")}
+`
+    );
+    return;
+  }
+  if (mode === "provider-assisted") {
+    io.write(
+      `${ui.note("Plain English: pick this if you want sift itself to finish more fuzzy cases before you have to step in or re-prompt an agent. Yes, that means an API key, but the model is intentionally the cheap backup, not the fancy main act.")}
+`
+    );
+    return;
+  }
+  io.write(
+    `${ui.note("Plain English: pick this if sift is working alone. No API key, no model fallback. If the answer is still fuzzy, you inspect the code or logs yourself.")}
+`
+  );
+}
+function writeSetupSuccess(io, writtenPath, mode) {
   const ui = getSetupPresenter(io);
   io.write(`
 ${ui.success("You're set.")}
 `);
   io.write(`${ui.info(`Machine-wide config: ${writtenPath}`)}
+`);
+  io.write(`${ui.labelValue("operation mode", getOperationModeLabel(mode))}
 `);
   io.write(`${ui.note("sift is ready to use from any terminal on this machine.")}
 `);
@@ -928,31 +1244,114 @@ function writeOverrideWarning(io, activeConfigPath) {
 `
   );
 }
-function writeNextSteps(io) {
+function writeNextSteps(io, mode) {
   const ui = getSetupPresenter(io);
   io.write(`
 ${ui.section("Try next")}
 `);
   io.write(`  ${ui.command("sift doctor")}
 `);
+  if (mode === "provider-assisted") {
+    io.write(`  ${ui.command("sift config show --show-secrets")}
+`);
+  } else {
+    io.write(
+      `  ${ui.command("sift config show")}${ui.note("  # rerun setup later if you want provider-assisted fallback")}
+`
+    );
+  }
   io.write(`  ${ui.command("sift exec --preset test-status -- npm test")}
 `);
 }
-function writeProviderDefaults(io, provider) {
+async function promptForProviderModel(args) {
+  const options = getProviderModelOptions(args.provider);
+  const customCurrent = args.currentModel && !findProviderModelOption(args.provider, args.currentModel) ? `Keep current custom model (${args.currentModel})` : "Custom model";
+  if (args.io.select) {
+    const labels = options.map((option) => `${option.label} - ${option.note}`);
+    labels.push(customCurrent);
+    const choice = await args.io.select(
+      "Pick the fallback model. Cheap is usually the right answer here; this only wakes up when sift needs help.",
+      labels,
+      "Model",
+      true
+    );
+    if (isBackSelection(choice)) {
+      return PROMPT_BACK;
+    }
+    const match = options.find((option) => choice.startsWith(option.label));
+    if (match) {
+      return match.model;
+    }
+    if (customCurrent.startsWith("Keep current custom model")) {
+      return args.currentModel ?? getDefaultProviderModel(args.provider);
+    }
+  } else {
+    args.io.write("\nPick the fallback model.\n\n");
+    options.forEach((option, index) => {
+      args.io.write(`  ${index + 1}) ${option.label} - ${option.note}
+`);
+    });
+    args.io.write(`  ${options.length + 1}) ${customCurrent}
+
+`);
+    while (true) {
+      const answer = (await args.io.ask("Model choice [1]: ")).trim();
+      if (answer.toLowerCase() === "back" || answer.toLowerCase() === "b") {
+        return PROMPT_BACK;
+      }
+      if (answer === "") {
+        return options[0].model;
+      }
+      const index = Number(answer);
+      if (Number.isInteger(index) && index >= 1 && index <= options.length) {
+        return options[index - 1].model;
+      }
+      if (Number.isInteger(index) && index === options.length + 1) {
+        break;
+      }
+      args.io.error(`Please enter a number between 1 and ${options.length + 1}.
+`);
+    }
+  }
+  while (true) {
+    const answer = (await args.io.ask("Custom model id: ")).trim();
+    if (answer.toLowerCase() === "back" || answer.toLowerCase() === "b") {
+      return PROMPT_BACK;
+    }
+    if (answer.length > 0) {
+      return answer;
+    }
+    args.io.error("Model id cannot be empty.\n");
+  }
+}
+function writeProviderDefaults(io, provider, selectedModel) {
   const ui = getSetupPresenter(io);
+  const options = getProviderModelOptions(provider);
   if (provider === "openrouter") {
-    io.write(`${ui.info("Using OpenRouter defaults for your first run.")}
+    io.write(`${ui.info("OpenRouter fallback it is. Free is lovely right up until latency develops a personality.")}
 `);
-    io.write(`${ui.labelValue("Default model", "openrouter/free")}
+    io.write(`${ui.labelValue("Default model", getDefaultProviderModel("openrouter"))}
 `);
     io.write(`${ui.labelValue("Default base URL", "https://openrouter.ai/api/v1")}
 `);
   } else {
-    io.write(`${ui.info("Using OpenAI defaults for your first run.")}
+    io.write(`${ui.info("OpenAI fallback it is. Start cheap, save the fancy stuff for when the logs deserve it.")}
 `);
-    io.write(`${ui.labelValue("Default model", "gpt-5-nano")}
+    io.write(`${ui.labelValue("Default model", getDefaultProviderModel("openai"))}
 `);
     io.write(`${ui.labelValue("Default base URL", "https://api.openai.com/v1")}
+`);
+  }
+  io.write(`${ui.labelValue("Selected model", selectedModel)}
+`);
+  io.write(
+    `${ui.note("This fallback only wakes up when sift's own rules are not enough. The idea is fewer dead ends, not paying for a second opinion on every command.")}
+`
+  );
+  io.write(`${ui.note("Popular alternatives:")}
+`);
+  for (const option of options.filter((option2) => option2.model !== selectedModel)) {
+    io.write(`  ${ui.command(option.label)}${ui.note(`  # ${option.note}`)}
 `);
   }
   io.write(
@@ -964,54 +1363,101 @@ function writeProviderDefaults(io, provider) {
 `
   );
 }
-function materializeProfile(provider, profile, apiKey) {
+function materializeProfile(provider, profile, overrides = {}) {
   return {
+    ...profile,
     ...getProfileProviderState(provider, profile),
-    ...apiKey !== void 0 ? { apiKey } : {}
+    ...overrides.model !== void 0 ? { model: overrides.model } : {},
+    ...overrides.apiKey !== void 0 ? { apiKey: overrides.apiKey } : {}
   };
 }
 function buildSetupConfig(args) {
   const preservedConfig = preserveActiveNativeProviderProfile(args.config);
+  if (args.mode !== "provider-assisted") {
+    return {
+      ...preservedConfig,
+      runtime: {
+        ...preservedConfig.runtime,
+        operationMode: args.mode
+      }
+    };
+  }
+  if (!args.provider || !args.apiKeyChoice) {
+    throw new Error("Provider-assisted setup requires provider and API key choice.");
+  }
   const storedProfile = getStoredProviderProfile(preservedConfig, args.provider);
   if (args.apiKeyChoice === "saved") {
     const profile2 = materializeProfile(
       args.provider,
       storedProfile,
-      storedProfile?.apiKey ?? ""
+      {
+        apiKey: storedProfile?.apiKey ?? "",
+        model: args.model
+      }
     );
     const configWithProfile2 = setStoredProviderProfile(
       preservedConfig,
       args.provider,
       profile2
     );
-    return applyActiveProvider(
+    const applied2 = applyActiveProvider(
       configWithProfile2,
       args.provider,
       profile2,
       profile2.apiKey ?? ""
     );
+    return {
+      ...applied2,
+      runtime: {
+        ...applied2.runtime,
+        operationMode: args.mode
+      }
+    };
   }
   if (args.apiKeyChoice === "env") {
-    const profile2 = storedProfile ? storedProfile : materializeProfile(args.provider, void 0);
-    const configWithProfile2 = storedProfile ? preservedConfig : setStoredProviderProfile(preservedConfig, args.provider, profile2);
-    return applyActiveProvider(configWithProfile2, args.provider, profile2, "");
+    const profile2 = materializeProfile(args.provider, storedProfile, {
+      model: args.model
+    });
+    const configWithProfile2 = setStoredProviderProfile(
+      preservedConfig,
+      args.provider,
+      profile2
+    );
+    const applied2 = applyActiveProvider(configWithProfile2, args.provider, profile2, "");
+    return {
+      ...applied2,
+      runtime: {
+        ...applied2.runtime,
+        operationMode: args.mode
+      }
+    };
   }
   const profile = materializeProfile(
     args.provider,
     storedProfile,
-    args.nextApiKey ?? ""
+    {
+      apiKey: args.nextApiKey ?? "",
+      model: args.model
+    }
   );
   const configWithProfile = setStoredProviderProfile(
     preservedConfig,
     args.provider,
     profile
   );
-  return applyActiveProvider(
+  const applied = applyActiveProvider(
     configWithProfile,
     args.provider,
     profile,
     args.nextApiKey ?? ""
   );
+  return {
+    ...applied,
+    runtime: {
+      ...applied.runtime,
+      operationMode: args.mode
+    }
+  };
 }
 async function configSetup(options = {}) {
   void options.global;
@@ -1025,29 +1471,119 @@ async function configSetup(options = {}) {
       );
       return 1;
     }
-    io.write(`${ui.welcome("Let's keep the expensive model for the interesting bits.")}
+    if (!options.embedded) {
+      io.write(`${ui.welcome("Let's keep the expensive model for the interesting bits.")}
+`);
+      io.write(`${ui.note('"Sharp first, expensive later."')}
+`);
+    } else {
+      io.write(`${ui.info("Next: provider, model, and credentials. Press Esc any time if you want to step back.")}
 `);
+    }
     const resolvedPath = resolveSetupPath(options.targetPath);
     const { config: existingConfig, existed } = loadEditableConfig(resolvedPath);
     if (existed) {
       io.write(`${ui.info(`Updating existing config at ${resolvedPath}.`)}
 `);
     }
-    const provider = await promptForProvider(io);
-    writeProviderDefaults(io, provider);
-    const storedProfile = getStoredProviderProfile(existingConfig, provider);
-    const envName = getNativeProviderApiKeyEnvName(provider);
-    const apiKeyChoice = await promptForApiKeyChoice({
-      io,
-      provider,
-      envName,
-      hasSavedKey: Boolean(storedProfile?.apiKey),
-      hasEnvKey: Boolean(env[envName])
-    });
-    const nextApiKey = apiKeyChoice === "override" ? await promptForApiKey(io, provider) : void 0;
+    let mode = options.forcedMode ?? await promptForOperationMode(io);
+    let provider;
+    let model;
+    let apiKeyChoice;
+    let nextApiKey;
+    let modeSummaryShown = false;
+    while (true) {
+      if (!modeSummaryShown) {
+        writeModeSummary(io, mode);
+        modeSummaryShown = true;
+      }
+      if (mode !== "provider-assisted") {
+        io.write(
+          `${ui.note("No provider credentials are required for this mode. You can switch later by running `sift config setup` again.")}
+`
+        );
+        break;
+      }
+      let providerStep = "provider";
+      while (true) {
+        if (providerStep === "provider") {
+          const providerChoice = await promptForProvider(io);
+          if (providerChoice === PROMPT_BACK) {
+            if (options.forcedMode) {
+              return options.embedded ? CONFIG_SETUP_BACK : 1;
+            }
+            mode = await promptForOperationMode(io);
+            modeSummaryShown = false;
+            provider = void 0;
+            model = void 0;
+            apiKeyChoice = void 0;
+            nextApiKey = void 0;
+            break;
+          }
+          provider = providerChoice;
+          providerStep = "model";
+          continue;
+        }
+        const storedProfile = getStoredProviderProfile(existingConfig, provider);
+        if (providerStep === "model") {
+          const modelChoice = await promptForProviderModel({
+            io,
+            provider,
+            currentModel: storedProfile?.model
+          });
+          if (modelChoice === PROMPT_BACK) {
+            providerStep = "provider";
+            continue;
+          }
+          model = modelChoice;
+          writeProviderDefaults(io, provider, model);
+          providerStep = "api-key-choice";
+          continue;
+        }
+        const envName = getNativeProviderApiKeyEnvName(provider);
+        if (providerStep === "api-key-choice") {
+          const keyChoice = await promptForApiKeyChoice({
+            io,
+            provider,
+            envName,
+            hasSavedKey: Boolean(storedProfile?.apiKey),
+            hasEnvKey: Boolean(env[envName])
+          });
+          if (keyChoice === PROMPT_BACK) {
+            providerStep = "model";
+            continue;
+          }
+          apiKeyChoice = keyChoice;
+          if (apiKeyChoice === "override") {
+            io.write(`${ui.note("Press Esc if you want to go back instead of entering a key right now.")}
+`);
+            providerStep = "api-key-entry";
+            continue;
+          }
+          nextApiKey = void 0;
+          break;
+        }
+        const apiKey = await promptForApiKey(io, provider);
+        if (apiKey === PROMPT_BACK) {
+          providerStep = "api-key-choice";
+          continue;
+        }
+        nextApiKey = apiKey;
+        break;
+      }
+      if (mode !== "provider-assisted") {
+        continue;
+      }
+      if (!provider || !apiKeyChoice) {
+        continue;
+      }
+      break;
+    }
     const config = buildSetupConfig({
       config: existingConfig,
+      mode,
       provider,
+      model,
       apiKeyChoice,
       nextApiKey
     });
@@ -1056,18 +1592,19 @@ async function configSetup(options = {}) {
       config,
       overwrite: existed
     });
-    if (apiKeyChoice === "env") {
+    if (mode === "provider-assisted" && provider && apiKeyChoice === "env") {
+      const envName = getNativeProviderApiKeyEnvName(provider);
       io.write(
         `${ui.note(`Using ${envName} from the environment. No API key was written to config.`)}
 `
       );
     }
-    writeSetupSuccess(io, writtenPath);
+    writeSetupSuccess(io, writtenPath, mode);
     const activeConfigPath = findConfigPath();
     if (activeConfigPath && path5.resolve(activeConfigPath) !== path5.resolve(writtenPath)) {
       writeOverrideWarning(io, activeConfigPath);
     }
-    writeNextSteps(io);
+    writeNextSteps(io, mode);
     return 0;
   } finally {
     io.close?.();
@@ -1094,18 +1631,18 @@ function maskConfigSecrets(value) {
   return output;
 }
 function configInit(targetPath, global = false) {
-  const path8 = writeExampleConfig({
+  const path9 = writeExampleConfig({
     targetPath,
     global
   });
   if (!process.stdout.isTTY) {
-    process.stdout.write(`${path8}
+    process.stdout.write(`${path9}
 `);
     return;
   }
   const ui = createPresentation(true);
   process.stdout.write(
-    `${ui.success(`${global ? "Machine-wide" : "Template"} config written to ${path8}`)}
+    `${ui.success(`${global ? "Machine-wide" : "Template"} config written to ${path9}`)}
 `
   );
 }
@@ -1268,16 +1805,34 @@ function getManagedBlockMarkers(agent) {
     end: `<!-- sift:end ${agent} -->`
   };
 }
-function renderInstructionBody() {
+function inferOperationMode(args) {
+  if (args.operationMode) {
+    return args.operationMode;
+  }
+  try {
+    const cwd = args.cwd ?? process.cwd();
+    const homeDir = args.homeDir ?? os2.homedir();
+    const repoConfigPath = path6.resolve(cwd, "sift.config.yaml");
+    const globalConfigPath = getDefaultGlobalConfigPath(homeDir);
+    const configPath = fs5.existsSync(repoConfigPath) ? repoConfigPath : fs5.existsSync(globalConfigPath) ? globalConfigPath : void 0;
+    const config = resolveConfig(configPath ? { configPath } : {});
+    return resolveEffectiveOperationMode(config);
+  } catch {
+    return "agent-escalation";
+  }
+}
+function renderInstructionBody(mode) {
   return [
-    "Use `sift` as the default reduction layer for long, noisy, non-interactive command output.",
-    "The goal is to shrink that output before it spends context-window and token budget in the model.",
+    "Use `sift` as the default local-first output guidance layer for long, noisy, non-interactive command output.",
+    "The goal is to turn failure walls into grouped issues, likely root causes, and the next useful step before reading raw logs.",
+    "",
+    `Default operating mode: ${getOperationModeLabel(mode)}.`,
+    describeOperationMode(mode),
+    describeInsufficientBehavior(mode),
     "",
     "Start with:",
     '- `sift exec "question" -- <command> [args...]`',
     "- `sift exec --preset test-status -- <test command>`",
-    '- `sift watch "what changed between cycles?" < watcher-output.txt`',
-    '- `sift exec --watch "what changed between cycles?" -- <command> [args...]`',
     "- `sift exec --preset audit-critical -- npm audit`",
     "- `sift exec --preset infra-risk -- terraform plan`",
     "",
@@ -1316,9 +1871,9 @@ function renderInstructionBody() {
     "Do not pass API keys inline."
   ].join("\n");
 }
-function renderManagedBlock(agent, eol = "\n") {
+function renderManagedBlock(agent, eol = "\n", mode = "agent-escalation") {
   const markers = getManagedBlockMarkers(agent);
-  return [markers.start, renderInstructionBody(), markers.end].join(eol);
+  return [markers.start, renderInstructionBody(mode), markers.end].join(eol);
 }
 function inspectManagedBlock(content, agent) {
   const markers = getManagedBlockMarkers(agent);
@@ -1343,7 +1898,7 @@ function inspectManagedBlock(content, agent) {
 }
 function planManagedInstall(args) {
   const eol = args.existingContent?.includes("\r\n") ? "\r\n" : "\n";
-  const block = renderManagedBlock(args.agent, eol);
+  const block = renderManagedBlock(args.agent, eol, args.operationMode ?? "agent-escalation");
   if (args.existingContent === void 0) {
     return {
       action: "create",
@@ -1433,6 +1988,7 @@ function showAgent(args, ioArg = createStdoutOnlyIO()) {
   const params = typeof args === "string" ? {
     agent: args,
     scope: "repo",
+    operationMode: void 0,
     raw: false,
     targetPath: void 0,
     cwd: void 0,
@@ -1441,6 +1997,7 @@ function showAgent(args, ioArg = createStdoutOnlyIO()) {
   } : {
     agent: args.agent,
     scope: args.scope ?? "repo",
+    operationMode: args.operationMode,
     raw: args.raw ?? false,
     targetPath: args.targetPath,
     cwd: args.cwd,
@@ -1449,8 +2006,13 @@ function showAgent(args, ioArg = createStdoutOnlyIO()) {
   };
   const agent = normalizeAgentName(params.agent);
   const io = params.io;
+  const operationMode = inferOperationMode({
+    cwd: params.cwd,
+    homeDir: params.homeDir,
+    operationMode: params.operationMode
+  });
   if (params.raw) {
-    io.write(`${renderManagedBlock(agent)}
+    io.write(`${renderManagedBlock(agent, "\n", operationMode)}
 `);
     return;
   }
@@ -1489,6 +2051,8 @@ function showAgent(args, ioArg = createStdoutOnlyIO()) {
     )}
 `
   );
+  io.write(`${ui.labelValue("operation mode", getOperationModeLabel(operationMode))}
+`);
   if (currentInstalled) {
     io.write(`${ui.warning(`Already installed in ${params.scope} scope.`)}
 `);
@@ -1506,13 +2070,17 @@ function showAgent(args, ioArg = createStdoutOnlyIO()) {
 `
   );
   io.write(
-    `${ui.info("The point is to reduce long command output before it burns context-window and token budget.")}
+    `${ui.info("The point is to narrow long command output before your agent burns time and tokens on the raw log wall.")}
 `
   );
   io.write(
     `${ui.info("The managed block teaches the agent to default to sift first, keep raw as the last resort, and treat standard as the usual stop point.")}
 `
   );
+  io.write(`${ui.note(describeOperationMode(operationMode))}
+`);
+  io.write(`${ui.note(describeInsufficientBehavior(operationMode))}
+`);
   io.write(`  ${ui.command('sift exec "question" -- <command> [args...]')}
 `);
   io.write(`  ${ui.command("sift exec --preset test-status -- <test command>")}
@@ -1522,7 +2090,7 @@ function showAgent(args, ioArg = createStdoutOnlyIO()) {
   io.write(`  ${ui.command("sift exec --preset infra-risk -- terraform plan")}
 `);
   io.write(
-    `${ui.info("For test debugging, standard should usually be enough for first-pass triage.")}
+    `${ui.info("For test debugging, standard should usually be enough for first-pass guidance.")}
 `
   );
   io.write(
@@ -1572,6 +2140,11 @@ async function installAgent(args) {
     homeDir: args.homeDir
   });
   const ui = createPresentation(io.stdoutIsTTY);
+  const operationMode = inferOperationMode({
+    cwd: args.cwd,
+    homeDir: args.homeDir,
+    operationMode: args.operationMode
+  });
   try {
     const existingContent = readOptionalFile(targetPath);
     const fileExists = existingContent !== void 0;
@@ -1579,7 +2152,8 @@ async function installAgent(args) {
     const plan = planManagedInstall({
       agent,
       targetPath,
-      existingContent
+      existingContent,
+      operationMode
     });
     if (args.dryRun) {
       if (args.raw) {
@@ -1635,6 +2209,8 @@ async function installAgent(args) {
       io.write(`${ui.labelValue("scope", scope)}
 `);
       io.write(`${ui.labelValue("target", targetPath)}
+`);
+      io.write(`${ui.labelValue("operation mode", getOperationModeLabel(operationMode))}
 `);
       io.write(`${ui.info("This will only manage the sift block.")}
 `);
@@ -1835,6 +2411,465 @@ function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+// src/commands/install.ts
+import os3 from "os";
+import path7 from "path";
+import { emitKeypressEvents as emitKeypressEvents2 } from "readline";
+import { createInterface as createInterface3 } from "readline/promises";
+import {
+  stderr as defaultStderr3,
+  stdin as defaultStdin4,
+  stdout as defaultStdout3
+} from "process";
+var INSTALL_TITLES = {
+  codex: "Codex",
+  claude: "Claude"
+};
+function createInstallTerminalIO() {
+  let rl;
+  function getInterface() {
+    if (!rl) {
+      rl = createInterface3({
+        input: defaultStdin4,
+        output: defaultStdout3,
+        terminal: true
+      });
+    }
+    return rl;
+  }
+  async function select(prompt, options, selectedLabel, allowBack) {
+    emitKeypressEvents2(defaultStdin4);
+    return await promptSelect({
+      input: defaultStdin4,
+      output: defaultStdout3,
+      prompt,
+      options,
+      selectedLabel,
+      allowBack
+    });
+  }
+  return {
+    stdinIsTTY: Boolean(defaultStdin4.isTTY),
+    stdoutIsTTY: Boolean(defaultStdout3.isTTY),
+    ask(prompt) {
+      return getInterface().question(prompt);
+    },
+    select,
+    write(message) {
+      defaultStdout3.write(message);
+    },
+    error(message) {
+      defaultStderr3.write(message);
+    },
+    close() {
+      rl?.close();
+    }
+  };
+}
+function normalizeInstallRuntime(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (value === "codex" || value === "claude" || value === "all") {
+    return value;
+  }
+  throw new Error("Invalid runtime. Use codex, claude, or all.");
+}
+function normalizeInstallScope(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (value === "global") {
+    return "global";
+  }
+  if (value === "local" || value === "repo") {
+    return "repo";
+  }
+  throw new Error("Invalid --scope value. Use local or global.");
+}
+function renderInstallBanner(version) {
+  const teal = (text) => `\x1B[38;2;34;173;169m${text}\x1B[0m`;
+  return [
+    teal("  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557"),
+    teal("  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D"),
+    teal("  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2557     \u2588\u2588\u2551   "),
+    teal("  \u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u255D     \u2588\u2588\u2551   "),
+    teal("  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2551        \u2588\u2588\u2551   "),
+    teal("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u255D        \u255A\u2550\u255D   "),
+    "",
+    `  sift v${version}`,
+    "  Small, sharp, and mildly sarcastic output guidance.",
+    '  "Loading the loading screen..." energy, minus the loading screen.'
+  ].join("\n");
+}
+function getInstallTargets(runtime) {
+  if (runtime === "all") {
+    return ["codex", "claude"];
+  }
+  return [runtime];
+}
+function getGlobalTargetLabel(agent, homeDir = os3.homedir()) {
+  return agent === "codex" ? getDefaultCodexGlobalInstructionsPath(homeDir) : getDefaultClaudeGlobalInstructionsPath(homeDir);
+}
+function getLocalTargetLabel(agent, cwd = process.cwd()) {
+  return agent === "codex" ? path7.join(cwd, "AGENTS.md") : path7.join(cwd, "CLAUDE.md");
+}
+function describeScopeChoice(args) {
+  const targets = getInstallTargets(args.runtime);
+  const labels = targets.map(
+    (agent) => args.scope === "global" ? getGlobalTargetLabel(agent, args.homeDir) : getLocalTargetLabel(agent, args.cwd)
+  );
+  return labels.join(" + ");
+}
+async function promptWithMenu(args) {
+  const defaultIndex = args.defaultIndex ?? 0;
+  if (args.io.select) {
+    const labels = args.choices.map((choice) => choice.label);
+    const selected = await args.io.select(args.prompt, labels, args.selectedLabel, args.allowBack);
+    if (selected === PROMPT_BACK) {
+      return PROMPT_BACK;
+    }
+    const match = args.choices.find((choice) => choice.label === selected);
+    if (match) {
+      return match.value;
+    }
+  }
+  args.io.write(`
+${args.prompt}
+
+`);
+  args.choices.forEach((choice, index) => {
+    args.io.write(`  ${index + 1}) ${choice.label}
+`);
+  });
+  if (args.allowBack) {
+    args.io.write(`  ${args.choices.length + 1}) Back
+`);
+  }
+  args.io.write("\n");
+  while (true) {
+    const answer = (await args.io.ask(`Choice [${defaultIndex + 1}]: `)).trim();
+    if (args.allowBack && (answer.toLowerCase() === "back" || answer.toLowerCase() === "b")) {
+      return PROMPT_BACK;
+    }
+    if (answer === "") {
+      return args.choices[defaultIndex]?.value ?? args.choices[0].value;
+    }
+    const choiceIndex = Number(answer);
+    if (Number.isInteger(choiceIndex) && choiceIndex >= 1 && choiceIndex <= args.choices.length) {
+      return args.choices[choiceIndex - 1].value;
+    }
+    if (args.allowBack && Number.isInteger(choiceIndex) && choiceIndex === args.choices.length + 1) {
+      return PROMPT_BACK;
+    }
+    const max = args.allowBack ? args.choices.length + 1 : args.choices.length;
+    args.io.error(`Please enter a number between 1 and ${max}.
+`);
+  }
+}
+async function promptForRuntime(io) {
+  return await promptWithMenu({
+    io,
+    prompt: "Choose your runtime",
+    selectedLabel: "Runtime",
+    allowBack: true,
+    choices: [
+      {
+        label: "Codex   (AGENTS.md / ~/.codex/AGENTS.md) - first-class if you live in Codex",
+        value: "codex"
+      },
+      {
+        label: "Claude  (CLAUDE.md / ~/.claude/CLAUDE.md) - same good manners, Claude-flavored",
+        value: "claude"
+      },
+      {
+        label: "All      - if you refuse to pick favorites today",
+        value: "all"
+      }
+    ]
+  });
+}
+async function promptForScope(args) {
+  return await promptWithMenu({
+    io: args.io,
+    prompt: "Choose where to install the runtime support",
+    selectedLabel: "Location",
+    allowBack: true,
+    choices: [
+      {
+        label: `Global (${describeScopeChoice({
+          runtime: args.runtime,
+          scope: "global",
+          cwd: args.cwd,
+          homeDir: args.homeDir
+        })}) - use this if you want sift ready everywhere`,
+        value: "global"
+      },
+      {
+        label: `Local  (${describeScopeChoice({
+          runtime: args.runtime,
+          scope: "repo",
+          cwd: args.cwd,
+          homeDir: args.homeDir
+        })}) - keep it here if this repo is the only one that matters`,
+        value: "repo"
+      }
+    ]
+  });
+}
+async function promptForOperationMode2(io) {
+  return await promptWithMenu({
+    io,
+    prompt: "Choose how sift should work",
+    selectedLabel: "Mode",
+    allowBack: true,
+    choices: [
+      {
+        label: "With an agent - recommended if Codex or Claude is already with you; sift does the fast local first pass, the agent only steps in when repo context is truly needed",
+        value: "agent-escalation"
+      },
+      {
+        label: "With provider fallback - recommended if you want sift to finish more ambiguous cases on its own before handing them back to you or your agent; needs an API key, cheap model only when needed",
+        value: "provider-assisted"
+      },
+      {
+        label: "Solo, local-only - recommended if you want zero model calls; great for supported presets, ambiguous cases stay with you",
+        value: "local-only"
+      }
+    ]
+  });
+}
+function createNestedInstallIO(parent) {
+  return {
+    stdinIsTTY: parent.stdinIsTTY,
+    stdoutIsTTY: parent.stdoutIsTTY,
+    ask: async () => "",
+    write() {
+    },
+    error(message) {
+      parent.error(message);
+    }
+  };
+}
+function writeSuccessSummary(args) {
+  const ui = createPresentation(args.io.stdoutIsTTY);
+  const targets = getInstallTargets(args.runtime);
+  const scopeLabel = args.scope === "global" ? "global" : "local";
+  const targetLabel = describeScopeChoice({
+    runtime: args.runtime,
+    scope: args.scope,
+    cwd: args.cwd,
+    homeDir: args.homeDir
+  });
+  if (args.io.stdoutIsTTY) {
+    args.io.write(`
+${ui.success("Installed runtime support.")}
+`);
+  } else {
+    args.io.write("Installed runtime support.\n");
+  }
+  args.io.write(
+    `${ui.note(`sift v${args.version} now manages ${targets.map((target) => INSTALL_TITLES[target]).join(" + ")} in ${scopeLabel} scope.`)}
+`
+  );
+  args.io.write(`${ui.note(`Operating mode: ${getOperationModeLabel(args.operationMode)}`)}
+`);
+  args.io.write(`${ui.note(describeOperationMode(args.operationMode))}
+`);
+  args.io.write(`${ui.note(targetLabel)}
+`);
+  args.io.write(`
+${ui.section("Try next")}
+`);
+  args.io.write(`  ${ui.command("sift doctor")}
+`);
+  if (args.operationMode === "provider-assisted") {
+    args.io.write(`  ${ui.command("sift config show --show-secrets")}
+`);
+  } else {
+    args.io.write(
+      `  ${ui.command("sift config setup")}${ui.note("  # optional if you want provider-assisted fallback later")}
+`
+    );
+  }
+  args.io.write(`  ${ui.command("sift exec --preset test-status -- npm test")}
+`);
+}
+async function installRuntimeSupport(options) {
+  const io = options.io ?? createInstallTerminalIO();
+  const getPreviousEditableStep = (step) => {
+    if (step === "runtime") {
+      return void 0;
+    }
+    if (step === "mode") {
+      return options.runtime ? void 0 : "runtime";
+    }
+    if (step === "scope") {
+      if (!options.operationMode) {
+        return "mode";
+      }
+      if (!options.runtime) {
+        return "runtime";
+      }
+      return void 0;
+    }
+    if (step === "provider") {
+      if (!options.scope) {
+        return "scope";
+      }
+      if (!options.operationMode) {
+        return "mode";
+      }
+      if (!options.runtime) {
+        return "runtime";
+      }
+      return void 0;
+    }
+    return void 0;
+  };
+  try {
+    if ((!io.stdinIsTTY || !io.stdoutIsTTY) && (!options.runtime || !options.scope || !options.yes)) {
+      io.error(
+        "sift install is interactive and requires a TTY. For non-interactive use `sift install codex --scope global --yes`.\n"
+      );
+      return 1;
+    }
+    if (io.stdoutIsTTY) {
+      io.write(`${renderInstallBanner(options.version)}
+`);
+    }
+    let runtime = options.runtime;
+    let operationMode = options.operationMode;
+    let scope = options.scope;
+    let step;
+    if (!io.stdinIsTTY || !io.stdoutIsTTY) {
+      runtime ??= options.runtime;
+      operationMode ??= "agent-escalation";
+      step = void 0;
+    } else if (!runtime) {
+      step = "runtime";
+    } else if (!operationMode) {
+      step = "mode";
+    } else if (!scope) {
+      step = "scope";
+    } else if (operationMode === "provider-assisted") {
+      step = "provider";
+    }
+    while (step) {
+      if (step === "runtime") {
+        const runtimeChoice = await promptForRuntime(io);
+        if (runtimeChoice === PROMPT_BACK) {
+          io.write(`
+${createPresentation(io.stdoutIsTTY).note("Install canceled before we touched anything.")}
+`);
+          return 0;
+        }
+        runtime = runtimeChoice;
+        step = !operationMode ? "mode" : !scope ? "scope" : operationMode === "provider-assisted" ? "provider" : void 0;
+        continue;
+      }
+      if (step === "mode") {
+        const modeChoice = await promptForOperationMode2(io);
+        if (modeChoice === PROMPT_BACK) {
+          const previous = getPreviousEditableStep("mode");
+          if (!previous) {
+            io.write(`
+${createPresentation(io.stdoutIsTTY).note("Install canceled before we touched anything.")}
+`);
+            return 0;
+          }
+          step = previous;
+          continue;
+        }
+        operationMode = modeChoice;
+        step = !scope ? "scope" : operationMode === "provider-assisted" ? "provider" : void 0;
+        continue;
+      }
+      if (step === "scope") {
+        const scopeChoice = await promptForScope({
+          io,
+          runtime,
+          cwd: options.cwd,
+          homeDir: options.homeDir
+        });
+        if (scopeChoice === PROMPT_BACK) {
+          const previous = getPreviousEditableStep("scope");
+          if (!previous) {
+            io.write(`
+${createPresentation(io.stdoutIsTTY).note("Install canceled before we touched anything.")}
+`);
+            return 0;
+          }
+          step = previous;
+          continue;
+        }
+        scope = scopeChoice;
+        step = operationMode === "provider-assisted" ? "provider" : void 0;
+        continue;
+      }
+      if (scope === "repo") {
+        io.write(
+          `
+${createPresentation(io.stdoutIsTTY).note("Local only applies to the runtime instructions in this repo. Provider fallback config is still machine-wide so sift can reuse it anywhere.")}
+`
+        );
+      }
+      io.write(`
+${createPresentation(io.stdoutIsTTY).info("Next: provider setup. Press Esc at any step to go back.")}
+`);
+      const setupStatus = await configSetup({
+        io,
+        env: process.env,
+        embedded: true,
+        forcedMode: "provider-assisted",
+        targetPath: getDefaultGlobalConfigPath(options.homeDir)
+      });
+      if (setupStatus === CONFIG_SETUP_BACK) {
+        const previous = getPreviousEditableStep("provider");
+        if (!previous) {
+          io.write(`
+${createPresentation(io.stdoutIsTTY).note("Install canceled before we touched anything.")}
+`);
+          return 0;
+        }
+        step = previous;
+        continue;
+      }
+      if (setupStatus !== 0) {
+        return setupStatus;
+      }
+      step = void 0;
+    }
+    const nestedIo = createNestedInstallIO(io);
+    for (const agent of getInstallTargets(runtime)) {
+      const status = await installAgent({
+        agent,
+        scope,
+        yes: true,
+        io: nestedIo,
+        operationMode,
+        cwd: options.cwd,
+        homeDir: options.homeDir
+      });
+      if (status !== 0) {
+        return status;
+      }
+    }
+    writeSuccessSummary({
+      io,
+      version: options.version,
+      runtime,
+      scope,
+      operationMode,
+      cwd: options.cwd,
+      homeDir: options.homeDir
+    });
+    return 0;
+  } finally {
+    io.close?.();
+  }
+}
+
 // src/commands/doctor.ts
 var PLACEHOLDER_API_KEYS = [
   "YOUR_API_KEY",
@@ -1858,16 +2893,21 @@ function isRealApiKey(key) {
 }
 function runDoctor(config, configPath) {
   const ui = createPresentation(Boolean(process.stdout.isTTY));
+  const effectiveMode = resolveEffectiveOperationMode(config);
   const apiKeyStatus = isRealApiKey(config.provider.apiKey) ? "set" : isPlaceholderApiKey(config.provider.apiKey) ? "placeholder (not a real key)" : "not set";
   const lines = [
     "sift doctor",
     "A quick check for your local setup.",
-    "mode: local config completeness check",
+    "mode: operation-mode health check",
     ui.labelValue("configPath", configPath ?? "(defaults only)"),
+    ui.labelValue("configuredMode", getOperationModeLabel(config.runtime.operationMode)),
+    ui.labelValue("effectiveMode", getOperationModeLabel(effectiveMode)),
     ui.labelValue("provider", config.provider.provider),
     ui.labelValue("model", config.provider.model),
     ui.labelValue("baseUrl", config.provider.baseUrl),
     ui.labelValue("apiKey", apiKeyStatus),
+    ui.labelValue("modeSummary", describeOperationMode(effectiveMode)),
+    ui.labelValue("insufficientBehavior", describeInsufficientBehavior(effectiveMode)),
     ui.labelValue("maxCaptureChars", String(config.input.maxCaptureChars)),
     ui.labelValue("maxInputChars", String(config.input.maxInputChars)),
     ui.labelValue("rawFallback", String(config.runtime.rawFallback))
@@ -1875,24 +2915,31 @@ function runDoctor(config, configPath) {
   process.stdout.write(`${lines.join("\n")}
 `);
   const problems = [];
-  if (!config.provider.baseUrl) {
-    problems.push("Missing provider.baseUrl");
-  }
-  if (!config.provider.model) {
-    problems.push("Missing provider.model");
-  }
-  if ((config.provider.provider === "openai" || config.provider.provider === "openai-compatible" || config.provider.provider === "openrouter") && !isRealApiKey(config.provider.apiKey)) {
-    if (isPlaceholderApiKey(config.provider.apiKey)) {
-      problems.push(`provider.apiKey looks like a placeholder: "${config.provider.apiKey}"`);
-    } else {
-      problems.push("Missing provider.apiKey");
+  if (config.runtime.operationMode === "provider-assisted") {
+    if (!config.provider.baseUrl) {
+      problems.push("Missing provider.baseUrl");
+    }
+    if (!config.provider.model) {
+      problems.push("Missing provider.model");
+    }
+    if ((config.provider.provider === "openai" || config.provider.provider === "openai-compatible" || config.provider.provider === "openrouter") && !isRealApiKey(config.provider.apiKey)) {
+      if (isPlaceholderApiKey(config.provider.apiKey)) {
+        problems.push(`provider.apiKey looks like a placeholder: "${config.provider.apiKey}"`);
+      } else {
+        problems.push("Missing provider.apiKey");
+      }
+      problems.push(
+        `Set one of: ${getProviderApiKeyEnvNames(
+          config.provider.provider,
+          config.provider.baseUrl
+        ).join(", ")}`
+      );
+    }
+    if (effectiveMode !== "provider-assisted") {
+      problems.push(
+        "Configured provider-assisted mode cannot activate yet, so sift will fall back to agent-escalation until provider credentials are usable."
+      );
     }
-    problems.push(
-      `Set one of: ${getProviderApiKeyEnvNames(
-        config.provider.provider,
-        config.provider.baseUrl
-      ).join(", ")}`
-    );
   }
   if (problems.length > 0) {
     if (process.stderr.isTTY) {
@@ -2749,16 +3796,16 @@ function extractBucketPathCandidates(args) {
   }
   return [...candidates];
 }
-function isConfigPathCandidate(path8) {
-  return /^\.github\/workflows\/.+\.(?:yml|yaml)$/i.test(path8) || /^(?:package\.json|pytest\.ini|pyproject\.toml|tox\.ini|(?:[A-Za-z0-9._/-]+\/)?conftest\.py)$/i.test(
-    path8
-  ) || /^(?:[A-Za-z0-9._/-]+\/)?(?:vitest|jest)\.config\.[A-Za-z0-9._-]+$/i.test(path8) || /^(?:[A-Za-z0-9._/-]+\/)?tsconfig(?:\.[A-Za-z0-9_-]+)?\.json$/i.test(path8) || /^[A-Za-z0-9._/-]*config[A-Za-z0-9._/-]*\.(?:json|yml|yaml)$/i.test(path8);
+function isConfigPathCandidate(path9) {
+  return /^\.github\/workflows\/.+\.(?:yml|yaml)$/i.test(path9) || /^(?:package\.json|pytest\.ini|pyproject\.toml|tox\.ini|(?:[A-Za-z0-9._/-]+\/)?conftest\.py)$/i.test(
+    path9
+  ) || /^(?:[A-Za-z0-9._/-]+\/)?(?:vitest|jest)\.config\.[A-Za-z0-9._-]+$/i.test(path9) || /^(?:[A-Za-z0-9._/-]+\/)?tsconfig(?:\.[A-Za-z0-9_-]+)?\.json$/i.test(path9) || /^[A-Za-z0-9._/-]*config[A-Za-z0-9._/-]*\.(?:json|yml|yaml)$/i.test(path9);
 }
-function isAppPathCandidate(path8) {
-  return path8.startsWith("src/");
+function isAppPathCandidate(path9) {
+  return path9.startsWith("src/");
 }
-function isTestPathCandidate(path8) {
-  return path8.startsWith("test/") || path8.startsWith("tests/");
+function isTestPathCandidate(path9) {
+  return path9.startsWith("test/") || path9.startsWith("tests/");
 }
 function looksLikeMatcherLiteralComparison(detail) {
   return /\bexpected\b[\s\S]*\bto (?:be|contain)\b/i.test(detail);
@@ -3321,13 +4368,13 @@ function buildExtendedBucketSearchHint(bucket, anchor) {
     return detail.replace(/^of\s+/i, "") || anchor.label;
   }
   if (extended.type === "file_not_found_failure") {
-    const path8 = detail.match(/['"]([^'"]+)['"]/)?.[1];
-    return path8 ?? detail;
+    const path9 = detail.match(/['"]([^'"]+)['"]/)?.[1];
+    return path9 ?? detail;
   }
   if (extended.type === "permission_denied_failure") {
-    const path8 = detail.match(/['"]([^'"]+)['"]/)?.[1];
+    const path9 = detail.match(/['"]([^'"]+)['"]/)?.[1];
     const port = detail.match(/\bport\s+(\d+)\b/i)?.[1];
-    return path8 ?? (port ? `port ${port}` : detail);
+    return path9 ?? (port ? `port ${port}` : detail);
   }
   return detail;
 }
@@ -4435,7 +5482,7 @@ function buildPrompt(args) {
     "If per-test or per-module mapping is unclear, fall back to the focused grouped-cause view instead of guessing."
   ] : [];
   const prompt = [
-    "You are Sift, a CLI output reduction assistant for downstream agents and automation.",
+    "You are Sift, a CLI output-guidance and reduction assistant for downstream agents and automation.",
     "Hard rules:",
     ...policy.sharedRules.map((rule) => `- ${rule}`),
     "",
@@ -6213,7 +7260,7 @@ function extractContractDriftEntities(input) {
 }
 function buildContractRepresentativeReason(args) {
   if (/openapi/i.test(args.label) && args.entities.apiPaths.length > 0) {
-    const nextPath = args.entities.apiPaths.find((path8) => !args.usedPaths.has(path8)) ?? args.entities.apiPaths[0];
+    const nextPath = args.entities.apiPaths.find((path9) => !args.usedPaths.has(path9)) ?? args.entities.apiPaths[0];
     args.usedPaths.add(nextPath);
     return `added path: ${nextPath}`;
   }
@@ -8290,7 +9337,7 @@ function emitStatsFooter(args) {
 
 // src/core/testStatusState.ts
 import fs6 from "fs";
-import path7 from "path";
+import path8 from "path";
 import { z as z3 } from "zod";
 var detailSchema = z3.enum(["standard", "focused", "verbose"]);
 var failureBucketTypeSchema = z3.enum([
@@ -8452,7 +9499,7 @@ function buildBucketSignature(bucket) {
   ]);
 }
 function basenameMatches(value, matcher) {
-  return matcher.test(path7.basename(value));
+  return matcher.test(path8.basename(value));
 }
 function isPytestExecutable(value) {
   return basenameMatches(value, /^pytest(?:\.exe)?$/i);
@@ -8611,7 +9658,7 @@ function buildCachedRunnerState(args) {
   };
 }
 function normalizeCwd(value) {
-  return path7.resolve(value).replace(/\\/g, "/");
+  return path8.resolve(value).replace(/\\/g, "/");
 }
 function buildTestStatusBaselineIdentity(args) {
   const cwd = normalizeCwd(args.cwd);
@@ -8760,7 +9807,7 @@ function tryReadCachedTestStatusRun(statePath = getDefaultTestStatusStatePath())
   }
 }
 function writeCachedTestStatusRun(state, statePath = getDefaultTestStatusStatePath()) {
-  fs6.mkdirSync(path7.dirname(statePath), {
+  fs6.mkdirSync(path8.dirname(statePath), {
     recursive: true
   });
   fs6.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}
@@ -9303,13 +10350,97 @@ function buildCommandPreview(request) {
   }
   return (request.command ?? []).join(" ");
 }
+function detectPackageManagerScriptKind(commandPreview) {
+  const trimmed = commandPreview.trim();
+  if (/^npm(?:\s+--?[^\s]+(?:[=\s][^\s]+)?)?\s+run\s+\S+/i.test(trimmed)) {
+    return "npm";
+  }
+  if (/^pnpm(?:\s+--?[^\s]+(?:[=\s][^\s]+)?)?\s+run\s+\S+/i.test(trimmed)) {
+    return "pnpm";
+  }
+  if (/^yarn(?:\s+--?[^\s]+(?:[=\s][^\s]+)?)?\s+run\s+\S+/i.test(trimmed)) {
+    return "yarn";
+  }
+  if (/^bun(?:\s+--?[^\s]+(?:[=\s][^\s]+)?)?\s+run\s+\S+/i.test(trimmed)) {
+    return "bun";
+  }
+  return null;
+}
+function normalizeScriptWrapperOutput(args) {
+  const kind = detectPackageManagerScriptKind(args.commandPreview);
+  if (!kind) {
+    return args.capturedOutput;
+  }
+  const lines = args.capturedOutput.split(/\r?\n/);
+  const trimBlankEdges = () => {
+    while (lines.length > 0 && lines[0].trim() === "") {
+      lines.shift();
+    }
+    while (lines.length > 0 && lines.at(-1).trim() === "") {
+      lines.pop();
+    }
+  };
+  const stripLeadingWrapperNoise = () => {
+    let removed = false;
+    while (lines.length > 0) {
+      const line = lines[0];
+      const trimmed = line.trim();
+      if (trimmed === "") {
+        lines.shift();
+        removed = true;
+        continue;
+      }
+      if (/^(?:npm|pnpm)\s+warn\s+unknown user config\b/i.test(trimmed) || /^(?:npm|pnpm)\s+warn\s+unknown env config\b/i.test(trimmed) || /^npm\s+warn\s+config\b/i.test(trimmed) || /^yarn\s+warning\b/i.test(trimmed) || /^bun\s+warn\b/i.test(trimmed)) {
+        lines.shift();
+        removed = true;
+        continue;
+      }
+      break;
+    }
+    if (removed) {
+      trimBlankEdges();
+    }
+  };
+  trimBlankEdges();
+  stripLeadingWrapperNoise();
+  if (kind === "npm" || kind === "pnpm") {
+    let removed = 0;
+    while (lines.length > 0 && removed < 2 && /^\s*>\s+/.test(lines[0])) {
+      lines.shift();
+      removed += 1;
+    }
+    trimBlankEdges();
+  }
+  if (kind === "yarn") {
+    if (lines[0] && /^\s*yarn run v/i.test(lines[0])) {
+      lines.shift();
+    }
+    if (lines[0] && /^\s*\$\s+/.test(lines[0])) {
+      lines.shift();
+    }
+    trimBlankEdges();
+    if (lines.at(-1) && /^\s*Done in\b/i.test(lines.at(-1))) {
+      lines.pop();
+    }
+  }
+  if (kind === "bun") {
+    if (lines[0] && /^\s*\$\s+/.test(lines[0])) {
+      lines.shift();
+    }
+  }
+  trimBlankEdges();
+  return lines.join("\n");
+}
 function getExecSuccessShortcut(args) {
   if (args.exitCode !== 0) {
     return null;
   }
-  if (args.presetName === "typecheck-summary" && args.capturedOutput.trim() === "") {
+  if (args.presetName === "typecheck-summary" && args.normalizedOutput.trim() === "") {
     return "No type errors.";
   }
+  if (args.presetName === "lint-failures" && args.normalizedOutput.trim() === "") {
+    return "No lint failures.";
+  }
   return null;
 }
 async function runExec(request) {
@@ -9389,6 +10520,10 @@ async function runExec(request) {
   }
   const exitCode = normalizeChildExitCode(childStatus, childSignal);
   const capturedOutput = capture.render();
+  const normalizedOutput = normalizeScriptWrapperOutput({
+    commandPreview,
+    capturedOutput
+  });
   const autoWatchDetected = !request.watch && looksLikeWatchStream(capturedOutput);
   const useWatchFlow = Boolean(request.watch) || autoWatchDetected;
   const shouldBuildTestStatusState = isTestStatusPreset && !useWatchFlow;
@@ -9414,7 +10549,7 @@ async function runExec(request) {
     const execSuccessShortcut = useWatchFlow ? null : getExecSuccessShortcut({
       presetName: request.presetName,
       exitCode,
-      capturedOutput
+      normalizedOutput
     });
     if (execSuccessShortcut && !request.dryRun) {
       if (request.config.runtime.verbose) {
@@ -9440,15 +10575,15 @@ async function runExec(request) {
     if (useWatchFlow) {
       let output2 = await runWatch({
         ...request,
-        stdin: capturedOutput
+        stdin: normalizedOutput
       });
       if (isInsufficientSignalOutput(output2)) {
         output2 = buildInsufficientSignalOutput({
           presetName: request.presetName,
-          originalLength: capture.getTotalChars(),
+          originalLength: normalizedOutput.length > 0 ? normalizedOutput.length : capture.getTotalChars(),
           truncatedApplied: capture.wasTruncated(),
           exitCode,
-          recognizedRunner: detectTestRunner(capturedOutput)
+          recognizedRunner: detectTestRunner(normalizedOutput)
         });
       }
       process.stdout.write(`${output2}
@@ -9487,7 +10622,7 @@ async function runExec(request) {
     }) : null;
     const result = await runSiftWithStats({
       ...request,
-      stdin: capturedOutput,
+      stdin: normalizedOutput,
       analysisContext: request.testStatusContext?.remainingMode && request.testStatusContext.remainingMode !== "none" && request.presetName === "test-status" ? [
         request.analysisContext,
         "Zoom context:",
@@ -9510,10 +10645,10 @@ async function runExec(request) {
       if (isInsufficientSignalOutput(output)) {
         output = buildInsufficientSignalOutput({
           presetName: request.presetName,
-          originalLength: capture.getTotalChars(),
+          originalLength: normalizedOutput.length > 0 ? normalizedOutput.length : capture.getTotalChars(),
           truncatedApplied: capture.wasTruncated(),
           exitCode,
-          recognizedRunner: detectTestRunner(capturedOutput)
+          recognizedRunner: detectTestRunner(normalizedOutput)
         });
       }
       if (request.diff && !request.dryRun && previousCachedRun && currentCachedRun) {
@@ -9540,10 +10675,10 @@ ${output}`;
     } else if (isInsufficientSignalOutput(output)) {
       output = buildInsufficientSignalOutput({
         presetName: request.presetName,
-        originalLength: capture.getTotalChars(),
+        originalLength: normalizedOutput.length > 0 ? normalizedOutput.length : capture.getTotalChars(),
         truncatedApplied: capture.wasTruncated(),
         exitCode,
-        recognizedRunner: detectTestRunner(capturedOutput)
+        recognizedRunner: detectTestRunner(normalizedOutput)
       });
     }
     process.stdout.write(`${output}
@@ -9654,6 +10789,7 @@ function getPreset(config, name) {
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../package.json");
 var defaultCliDeps = {
+  installRuntimeSupport,
   installAgent,
   removeAgent,
   showAgent,
@@ -10008,7 +11144,7 @@ function createCliApp(args = {}) {
     });
   });
   applySharedOptions(
-    cli.command("exec [question]", "Run a command and shrink its output for the model").allowUnknownOptions()
+    cli.command("exec [question]", "Run a command and turn noisy output into a smaller first pass for the model").allowUnknownOptions()
   ).usage("exec [question] [options] -- <program> [args...]").example('exec "what changed?" -- git diff').example("exec --preset test-status -- npm test").example("exec --preset test-status --diff -- npm test").example('exec --watch "summarize the stream" -- node watcher.js').example('exec --preset infra-risk --shell "terraform plan"').option("--shell <command>", "Execute a shell command string instead of argv mode").option("--preset <name>", "Run a named preset in exec mode").option("--watch", "Treat the command output as a watch/change-summary stream").option("--diff", "Prepend material changes versus the previous matching test-status run").action(async (question, options) => {
     if (question === "preset") {
       throw new Error("Use 'sift exec --preset <name> -- <program> ...' instead.");
@@ -10287,6 +11423,14 @@ function createCliApp(args = {}) {
     stdout.write(`${output}
 `);
   });
+  cli.command("install [runtime]", "Interactive runtime installer for Codex and Claude").usage("install [runtime] [options]").example("install").example("install codex").example("install codex --scope global --yes").example("install all --scope local --yes").option("--scope <scope>", "Install scope: local | global").option("--yes", "Skip prompts when runtime and scope are already provided").action(async (runtime, options) => {
+    process.exitCode = await deps.installRuntimeSupport({
+      runtime: normalizeInstallRuntime(runtime),
+      scope: normalizeInstallScope(options.scope),
+      yes: Boolean(options.yes),
+      version
+    });
+  });
   cli.command("agent <action> [name]", "Agent commands: show | install | remove | status").usage("agent <show|install|remove|status> [name] [options]").example("agent show codex").example("agent show codex --raw").example("agent install codex").example("agent install claude --scope global").example("agent install codex --dry-run").example("agent install codex --dry-run --raw").example("agent status").example("agent remove codex --scope repo").option("--scope <scope>", "Install scope: repo | global").option("--dry-run", "Show a short plan without changing files").option("--raw", "Print the exact managed block or dry-run file content").option("--yes", "Skip confirmation prompts when writing").option("--path <path>", "Explicit target path for install or remove").action(async (action, name, options) => {
     const scope = normalizeAgentScope(options.scope);
     if (action === "show") {
@@ -10430,14 +11574,14 @@ function createCliApp(args = {}) {
       {
         title: ui.section("Quick start"),
         body: [
-          `  ${ui.command("sift config setup")}`,
+          `  ${ui.command("sift install")}${ui.note("  # choose agent-escalation, provider-assisted, or local-only")}`,
           `  ${ui.command("sift exec --preset test-status -- npm test")}`,
           `  ${ui.command("sift exec --preset test-status -- npm test")}${ui.note("  # stop here if standard already shows the main buckets")}`,
           `  ${ui.command("sift rerun")}${ui.note("  # rerun the cached full suite after a fix")}`,
           `  ${ui.command("sift rerun --remaining --detail focused")}${ui.note("  # zoom into what is still failing")}`,
           `  ${ui.command("sift rerun --remaining --detail verbose --show-raw")}`,
-          `  ${ui.command('sift watch "what changed between cycles?" < watcher-output.txt')}`,
-          `  ${ui.command('sift exec --watch "what changed between cycles?" -- node watcher.js')}`,
+          `  ${ui.command("sift config setup")}${ui.note("  # optional if you want provider-assisted fallback")}`,
+          `  ${ui.command("sift install codex --scope global --yes")}`,
           `  ${ui.command("sift agent install codex --dry-run")}`,
           `  ${ui.command("sift agent install codex --dry-run --raw")}`,
           `  ${ui.command("sift agent status")}`,