@sailresearch/code 0.1.0 → 0.1.2

package/README.md

@@ -16,6 +16,21 @@ persist nothing.
 
 Claude Code itself must be installed (`npm install -g @anthropic-ai/claude-code`).
 
+## Trusted workspaces (no permission prompts)
+
+For trusted repos, containers, or VMs where you want long-running agent tasks
+without clicking through Claude Code permission prompts:
+
+```sh
+npx @sailresearch/code --trusted
+```
+
+`--trusted` launches Claude Code in bypass-permissions mode. This avoids Claude
+Code's auto-mode safety classifier path, so it also avoids failures like
+`safety classifier temporarily unavailable` when Sail model requests are
+otherwise healthy. Use it only where you are comfortable letting Claude Code run
+tools without prompting.
+
 ## Persistent setup / VS Code
 
 To make `claude` route to Sail without the launcher (for VS Code, or a bare
@@ -49,12 +64,36 @@ Notes:
 ## Choosing models
 
 ```sh
-npx @sailresearch/code --model zai-org/GLM-5.2-FP8 --background-model openai/gpt-oss-120b
+npx @sailresearch/code --model moonshotai/Kimi-K2.6
 ```
 
-Both tiers default to GLM-5.2. `--background-model` moves Claude Code's
-haiku/background tier (titles, summaries) to a cheaper model from the
-[Sail catalog](https://docs.sailresearch.com/models).
+GLM-5.2 is the default. The `/model` picker also exposes Kimi-K2.6 via Sail.
+Use `--model` with any model from the [Sail catalog](https://docs.sailresearch.com/models)
+to launch directly into that model.
+
+The launcher and `setup` write Claude Code's `availableModels` setting so fresh
+local sessions show only Sail-backed picker rows. Claude Code concatenates
+non-managed `availableModels` from user, project, local, and temporary settings,
+though, so rows from another settings scope may still appear. Rows that name
+non-Sail models (for example `claude-*` IDs) still route to Sail and will not be
+served there; remove them from the other settings file or enforce the picker
+with managed settings. `sail-code` prints a warning when it can see those extra
+rows.
+
+The launcher does **not** force a completion window: Claude Code has no flag
+for adding request metadata, so requests go out without `completion_window` and
+Sail's API default applies. See [Completion windows](https://docs.sailresearch.com/completion-windows)
+for the latency/price tradeoff and how to opt into another tier.
+
+## Commit attribution
+
+`setup` sets Claude Code's `attribution.commit` to a Sail co-author trailer
+naming the resolved model (e.g.
+`Co-Authored-By: GLM-5.2 via Sail <noreply@sailresearch.com>` — a `--model`
+override names that model instead) so commits the agent makes are attributed to
+the Sail-served model instead of Anthropic's default trailer; `attribution.pr`
+is emptied. `setup --revert` restores your original `attribution` (from the
+backup) or removes the trailer if the settings file was created by `sail-code`.
 
 ## Passing flags to claude
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sailresearch/code",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Run Claude Code on GLM-5.2 via Sail — one command, no Anthropic account.",
   "license": "MIT",
   "author": "Sail Research",

package/src/cli.js

@@ -15,6 +15,12 @@ import { resolveCredentials, run } from "./run.js";
 import { revert, setup } from "./setup.js";
 
 const require = createRequire(import.meta.url);
+const TRUSTED_CLAUDE_ARGS = ["--permission-mode", "bypassPermissions"];
+const CLAUDE_PERMISSION_FLAGS = [
+  "--permission-mode",
+  "--dangerously-skip-permissions",
+  "--allow-dangerously-skip-permissions",
+];
 
 const HELP = `sail-code — run Claude Code on GLM-5.2 via Sail (no Anthropic account)
 
@@ -29,6 +35,7 @@ Flags:
   --model <id>             Main model (default ${DEFAULT_MODEL})
   --background-model <id>  Background/haiku-tier model (default: same as --model)
   --mode <name>            Sail environment: ${MODE_VALUES.join(" | ")}
+  --trusted                Skip Claude Code permission prompts in trusted workspaces
   -h, --help               Show this help
   -v, --version            Show the version
 
@@ -44,6 +51,7 @@ export function parseArgs(argv) {
     modeFlag: undefined,
     scope: undefined,
     revert: false,
+    trusted: false,
     help: false,
     version: false,
     claudeArgs: [],
@@ -85,6 +93,7 @@ export function parseArgs(argv) {
     } else if (arg === "--user") parsed.scope = "user";
     else if (arg === "--project") parsed.scope = "project";
     else if (arg === "--revert") parsed.revert = true;
+    else if (arg === "--trusted") parsed.trusted = true;
     else if (arg === "-h" || arg === "--help") parsed.help = true;
     else if (arg === "-v" || arg === "--version") parsed.version = true;
     else
@@ -99,6 +108,22 @@ export function parseArgs(argv) {
   if (parsed.scope && parsed.command !== "setup") {
     throw new Error(`--${parsed.scope} only applies to setup`);
   }
+  if (parsed.trusted && parsed.command !== "run") {
+    throw new Error("--trusted only applies when launching claude");
+  }
+  if (parsed.trusted) {
+    const conflict = parsed.claudeArgs.find((arg) =>
+      CLAUDE_PERMISSION_FLAGS.some(
+        (flag) => arg === flag || arg.startsWith(`${flag}=`),
+      ),
+    );
+    if (conflict) {
+      throw new Error(
+        `--trusted conflicts with Claude permission flag "${conflict}" after --`,
+      );
+    }
+    parsed.claudeArgs = [...TRUSTED_CLAUDE_ARGS, ...parsed.claudeArgs];
+  }
   return parsed;
 }
 
@@ -159,6 +184,7 @@ export async function main() {
         modeFlag: args.modeFlag,
         model: args.model,
         backgroundModel: args.backgroundModel,
+        trusted: args.trusted,
         claudeArgs: args.claudeArgs,
       });
   }

package/src/constants.js

@@ -8,6 +8,7 @@
  */
 
 export const DEFAULT_MODEL = "zai-org/GLM-5.2-FP8";
+export const KIMI_MODEL = "moonshotai/Kimi-K2.6";
 
 /** Public API targets by mode name, mirroring the Sail CLI's mode map. */
 export const MODE_API_URLS = {
@@ -44,6 +45,68 @@ export const DEFAULT_APP_URL = "https://app.sailresearch.com";
  */
 export const DEFAULT_MODEL_CAPABILITIES = "effort,thinking";
 
+/**
+ * Display metadata for aliases pinned to the DEFAULT (GLM) model. Claude Code
+ * otherwise renders the pinned slots with built-in Anthropic-tier names and
+ * pricing (e.g. "Custom Opus model", "$5/$25 per Mtok"), which is wrong for a
+ * Sail-served GLM row. `_NAME` is the picker label; `_DESCRIPTION` is the
+ * per-row subtitle, where we surface Sail's standard-tier pricing for GLM-5.2
+ * (see config/models.json: $0.50 input / $2.50 output per 1M tokens). Like
+ * `_SUPPORTED_CAPABILITIES`, these are keyed to the ALIAS, so we only set them
+ * for aliases pinned to the known default model — a user-overridden --model
+ * gets no labels (built-in detection) rather than a mislabel.
+ */
+export const DEFAULT_MODEL_NAME = "GLM-5.2 via Sail";
+export const DEFAULT_MODEL_DESCRIPTION =
+  "Sail standard pricing: $0.50 input / $2.50 output per 1M tokens";
+export const KIMI_MODEL_NAME = "Kimi-K2.6 via Sail";
+export const KIMI_MODEL_DESCRIPTION =
+  "Sail pricing: priority $0.45 input / $3.00 output, ASAP $1.00 input / $4.00 output per 1M tokens";
+export const KIMI_MODEL_CAPABILITIES = "effort,thinking,xhigh_effort";
+
+export function buildModelPickerSettings(
+  mainModel = DEFAULT_MODEL,
+  backgroundModel = mainModel,
+) {
+  return {
+    availableModels: [
+      ...new Set([
+        DEFAULT_MODEL,
+        mainModel || DEFAULT_MODEL,
+        backgroundModel || mainModel || DEFAULT_MODEL,
+        KIMI_MODEL,
+      ]),
+    ],
+    enforceAvailableModels: true,
+  };
+}
+
+export function extraAvailableModels(settings, mainModel, backgroundModel) {
+  if (!Array.isArray(settings?.availableModels)) return [];
+  const allowed = new Set(
+    buildModelPickerSettings(mainModel, backgroundModel).availableModels,
+  );
+  return [
+    ...new Set(
+      settings.availableModels.filter(
+        (model) => typeof model === "string" && !allowed.has(model),
+      ),
+    ),
+  ];
+}
+
+export function formatExtraAvailableModelsWarning(source, extras) {
+  if (extras.length === 0) return null;
+  return (
+    `Warning: ${source} already allows model(s) outside Sail's picker list: ` +
+    `${extras.join(", ")}. Claude Code concatenates non-managed ` +
+    "`availableModels` across user/project/local settings, so those rows " +
+    "may remain selectable. Rows that name non-Sail models (for example " +
+    "`claude-*` IDs) still route to Sail and will not be served there. Remove " +
+    "them from that settings file or enforce the picker with managed settings."
+  );
+}
+
 export function buildClaudeEnv({ apiUrl, apiKey, model, backgroundModel }) {
   const base = String(apiUrl ?? "").replace(/\/+$/, "");
   const main = model || DEFAULT_MODEL;
@@ -63,6 +126,10 @@ export function buildClaudeEnv({ apiUrl, apiKey, model, backgroundModel }) {
     if (m === DEFAULT_MODEL) {
       capabilities[`ANTHROPIC_DEFAULT_${alias}_MODEL_SUPPORTED_CAPABILITIES`] =
         DEFAULT_MODEL_CAPABILITIES;
+      capabilities[`ANTHROPIC_DEFAULT_${alias}_MODEL_NAME`] =
+        DEFAULT_MODEL_NAME;
+      capabilities[`ANTHROPIC_DEFAULT_${alias}_MODEL_DESCRIPTION`] =
+        DEFAULT_MODEL_DESCRIPTION;
     }
   }
   return {
@@ -78,8 +145,17 @@ export function buildClaudeEnv({ apiUrl, apiKey, model, backgroundModel }) {
     ANTHROPIC_DEFAULT_SONNET_MODEL: main,
     ANTHROPIC_DEFAULT_HAIKU_MODEL: background,
     ANTHROPIC_DEFAULT_FABLE_MODEL: main,
-    // Declare effort/thinking for aliases pinned to the default GLM model
-    // (see DEFAULT_MODEL_CAPABILITIES). Custom overrides get no declaration.
+    // Add a single explicit Kimi row to the /model picker. Claude Code supports
+    // only one custom option this way; keep aliases pinned separately above so
+    // built-in Claude IDs cannot leak through to Sail.
+    ANTHROPIC_CUSTOM_MODEL_OPTION: KIMI_MODEL,
+    ANTHROPIC_CUSTOM_MODEL_OPTION_NAME: KIMI_MODEL_NAME,
+    ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION: KIMI_MODEL_DESCRIPTION,
+    ANTHROPIC_CUSTOM_MODEL_OPTION_SUPPORTED_CAPABILITIES:
+      KIMI_MODEL_CAPABILITIES,
+    // Declare effort/thinking and friendly display metadata for aliases pinned
+    // to the default GLM model (see DEFAULT_MODEL_CAPABILITIES / _NAME /
+    // _DESCRIPTION). Custom overrides get no declaration.
     ...capabilities,
     // Pin subagents to the main Sail model. CLAUDE_CODE_SUBAGENT_MODEL is the
     // highest-priority subagent model source — it outranks a subagent's

package/src/run.js

@@ -14,6 +14,9 @@ import {
   HEADER_INJECTION_VARS,
   MODEL_ALIAS_COMPANION_VARS,
   buildClaudeEnv,
+  buildModelPickerSettings,
+  extraAvailableModels,
+  formatExtraAvailableModelsWarning,
 } from "./constants.js";
 import {
   loadAuthKey,
@@ -203,6 +206,72 @@ export function buildSettingsEnv(sailEnv) {
   return settingsEnv;
 }
 
+export function buildRuntimeSettings(sailEnv) {
+  return {
+    env: buildSettingsEnv(sailEnv),
+    ...buildModelPickerSettings(
+      sailEnv.ANTHROPIC_MODEL,
+      sailEnv.ANTHROPIC_DEFAULT_HAIKU_MODEL,
+    ),
+  };
+}
+
+function userClaudeSettingsPath() {
+  const configDir = process.env.CLAUDE_CONFIG_DIR?.trim();
+  return path.join(
+    configDir || path.join(os.homedir(), ".claude"),
+    "settings.json",
+  );
+}
+
+function projectClaudeSettingsPaths() {
+  const claudeDir = path.join(process.cwd(), ".claude");
+  return [
+    path.join(claudeDir, "settings.json"),
+    path.join(claudeDir, "settings.local.json"),
+  ];
+}
+
+function readJSONFileBestEffort(filePath) {
+  try {
+    const text = fs.readFileSync(filePath, "utf8").replace(/^\uFEFF/, "");
+    const parsed = JSON.parse(text);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+    // Runtime picker warnings are advisory; malformed or missing settings files
+    // should not block launching Claude Code.
+  }
+  return null;
+}
+
+export function lowerScopeAvailableModelWarnings(sailEnv, paths) {
+  const mainModel = sailEnv.ANTHROPIC_MODEL;
+  const backgroundModel = sailEnv.ANTHROPIC_DEFAULT_HAIKU_MODEL;
+  return paths
+    .map((filePath) => {
+      const settings = readJSONFileBestEffort(filePath);
+      if (!settings) return null;
+      const extras = extraAvailableModels(settings, mainModel, backgroundModel);
+      return formatExtraAvailableModelsWarning(filePath, extras);
+    })
+    .filter(Boolean);
+}
+
+export function runtimeAvailableModelWarnings(sailEnv) {
+  return lowerScopeAvailableModelWarnings(sailEnv, [
+    userClaudeSettingsPath(),
+    ...projectClaudeSettingsPaths(),
+  ]);
+}
+
+function warnRuntimeAvailableModels(sailEnv) {
+  for (const warning of runtimeAvailableModelWarnings(sailEnv)) {
+    console.error(warning);
+  }
+}
+
 /**
  * Spawn `claude` with the Sail env overlaid; resolves to its exit code.
  *
@@ -226,6 +295,7 @@ export async function runClaude({ env, claudeArgs, spawn = spawnClaude }) {
         "override it.",
     );
   } else {
+    warnRuntimeAvailableModels(env);
     settingsFile = path.join(
       os.tmpdir(),
       `sail-code-${crypto.randomBytes(8).toString("hex")}.json`,
@@ -233,7 +303,7 @@ export async function runClaude({ env, claudeArgs, spawn = spawnClaude }) {
     try {
       fs.writeFileSync(
         settingsFile,
-        JSON.stringify({ env: buildSettingsEnv(env) }, null, 2),
+        JSON.stringify(buildRuntimeSettings(env), null, 2),
         { mode: 0o600 },
       );
     } catch (err) {
@@ -317,9 +387,20 @@ export async function runClaude({ env, claudeArgs, spawn = spawnClaude }) {
 }
 
 /** The `run` command. */
-export async function run({ modeFlag, model, backgroundModel, claudeArgs }) {
+export async function run({
+  modeFlag,
+  model,
+  backgroundModel,
+  trusted,
+  claudeArgs,
+}) {
   const { apiKey, apiUrl } = await resolveCredentials({ modeFlag });
   const env = buildClaudeEnv({ apiUrl, apiKey, model, backgroundModel });
+  if (trusted) {
+    console.error(
+      "Trusted mode: skipping Claude Code permission prompts. Use only in trusted workspaces.",
+    );
+  }
   console.error(
     `Running Claude Code on ${env.ANTHROPIC_MODEL} via Sail (${apiUrl}) — ` +
       "no Anthropic account used.",

package/src/setup.js

@@ -18,16 +18,192 @@ import path from "node:path";
 
 import {
   CONFLICTING_PROVIDER_VARS,
+  DEFAULT_MODEL,
   HEADER_INJECTION_VARS,
   MODEL_ALIAS_COMPANION_VARS,
   OWNED_ENV_KEYS,
   buildClaudeEnv,
+  buildModelPickerSettings,
+  extraAvailableModels,
+  formatExtraAvailableModelsWarning,
 } from "./constants.js";
 import { atomicWrite } from "./credentials.js";
 import { resolveCredentials } from "./run.js";
 
 export const BACKUP_SUFFIX = ".sail-backup";
 
+/**
+ * Build the Sail commit-attribution trailer for the resolved main model. Claude
+ * Code's top-level `attribution.commit` is the trailer appended to commits/PRs
+ * the agent makes; the default is a Claude/model-derived trailer. We replace it
+ * with a Sail trailer so commits made through the launcher are attributed to
+ * the Sail-served model, not Anthropic. The trailer names the model the session
+ * actually uses — for the default GLM model that's the friendly "GLM-5.2"; for
+ * a user-selected `--model` we use the model id's basename (e.g.
+ * `openai/gpt-oss-120b` → `gpt-oss-120b`) so a non-default setup isn't
+ * misattributed to GLM-5.2. `attribution.pr` is the PR-body attribution line;
+ * empty disables it (we don't add one).
+ */
+export function sailCommitTrailer(mainModel) {
+  const model = mainModel || DEFAULT_MODEL;
+  const label =
+    model === DEFAULT_MODEL ? "GLM-5.2" : model.split("/").pop() || model;
+  return `Co-Authored-By: ${label} via Sail <noreply@sailresearch.com>`;
+}
+
+/** `attribution.pr` value sail-code writes (empty = disable PR attribution). */
+export const SAIL_PR_ATTRIBUTION = "";
+
+/**
+ * Keys of the `attribution` object this tool WRITES in setup. `sessionUrl` is
+ * left alone (unset unless we confirm Claude Code appends it in this path — we
+ * avoid changing more attribution behavior than requested). Note: revert's
+ * no-backup path strips only the distinctive `commit` trailer (see revert()),
+ * not `pr` — `pr: ""` is meaningful user config (Claude Code's documented way
+ * to disable PR attribution) and indistinguishable from what we write.
+ */
+export const OWNED_ATTRIBUTION_KEYS = ["commit", "pr"];
+export const MANAGED_MODEL_PICKER_ENV_KEY = "SAIL_CODE_MANAGED_MODEL_PICKER";
+
+/**
+ * Merge the Sail commit attribution into a settings object's top-level
+ * `attribution`. `mainModel` is the resolved startup model (the `main` from
+ * buildClaudeEnv) so the trailer names the model the session actually uses,
+ * including a user-selected `--model`. Preserves any unrelated attribution
+ * keys the user set (e.g. sessionUrl). Mutates `settings.attribution`.
+ * Exported so tests exercise the real merge, not a copy.
+ */
+export function mergeAttribution(settings, mainModel) {
+  settings.attribution = {
+    ...(settings.attribution ?? {}),
+    commit: sailCommitTrailer(mainModel),
+    pr: SAIL_PR_ATTRIBUTION,
+  };
+}
+
+export function mergeModelPickerSettings(settings, mainModel, backgroundModel) {
+  const pickerSettings = buildModelPickerSettings(mainModel, backgroundModel);
+  Object.assign(settings, pickerSettings);
+  // Record the exact non-secret picker list setup wrote. If the byte backup is
+  // lost, fallback revert can then strip custom-model picker settings without
+  // guessing whether an arbitrary row was Sail-generated or user-managed.
+  settings.env = {
+    ...(settings.env ?? {}),
+    [MANAGED_MODEL_PICKER_ENV_KEY]: JSON.stringify(pickerSettings),
+  };
+}
+
+function sameStringArray(a, b) {
+  return (
+    Array.isArray(a) &&
+    Array.isArray(b) &&
+    a.length === b.length &&
+    a.every((value, i) => value === b[i])
+  );
+}
+
+function sameModelPickerSettings(settings, pickerSettings) {
+  return (
+    pickerSettings?.enforceAvailableModels === true &&
+    settings?.enforceAvailableModels === true &&
+    sameStringArray(settings.availableModels, pickerSettings.availableModels)
+  );
+}
+
+function managedModelPickerSettings(settings) {
+  const encoded = settings?.env?.[MANAGED_MODEL_PICKER_ENV_KEY];
+  if (typeof encoded !== "string") return null;
+  try {
+    const parsed = JSON.parse(encoded);
+    if (
+      parsed &&
+      typeof parsed === "object" &&
+      !Array.isArray(parsed) &&
+      parsed.enforceAvailableModels === true &&
+      Array.isArray(parsed.availableModels) &&
+      parsed.availableModels.every((model) => typeof model === "string")
+    ) {
+      return parsed;
+    }
+  } catch {
+    // Malformed marker: ignore it and fall back to the exact default matcher.
+  }
+  return null;
+}
+
+export function isSailGeneratedModelPickerSettings(settings) {
+  const managedPicker = managedModelPickerSettings(settings);
+  if (managedPicker) {
+    return sameModelPickerSettings(settings, managedPicker);
+  }
+  return sameModelPickerSettings(
+    settings,
+    buildModelPickerSettings(DEFAULT_MODEL),
+  );
+}
+
+function readSettingsIfPresent(filePath) {
+  try {
+    return readSettings(filePath);
+  } catch {
+    // Best-effort sibling-scope inspection for warnings only. The target
+    // settings file is parsed strictly by setup(); a sibling project
+    // settings.json should not block writing the local Sail file.
+    return { settings: {}, existed: false };
+  }
+}
+
+function projectSharedSettingsPath(localSettingsPath) {
+  return path.join(path.dirname(localSettingsPath), "settings.json");
+}
+
+function currentProjectSettingsPaths() {
+  const claudeDir = path.join(process.cwd(), ".claude");
+  return [
+    path.join(claudeDir, "settings.json"),
+    path.join(claudeDir, "settings.local.json"),
+  ];
+}
+
+export function extraAvailableModelWarningSources({
+  scope,
+  filePath,
+  settings,
+  mainModel,
+  backgroundModel,
+}) {
+  const background = backgroundModel || mainModel;
+  const seenPaths = new Set();
+  const sources = [];
+
+  const addSource = (source, sourceSettings) => {
+    const resolved = path.resolve(source);
+    if (seenPaths.has(resolved)) return;
+    seenPaths.add(resolved);
+    const extras = extraAvailableModels(sourceSettings, mainModel, background);
+    if (extras.length > 0) sources.push({ source, extras });
+  };
+
+  addSource(filePath, settings);
+
+  const extraPaths =
+    scope === "project"
+      ? [projectSharedSettingsPath(filePath)]
+      : currentProjectSettingsPaths();
+
+  for (const source of extraPaths) {
+    const { settings: sourceSettings, existed } = readSettingsIfPresent(source);
+    if (existed) addSource(source, sourceSettings);
+  }
+
+  return sources;
+}
+
+function warnExtraAvailableModels(source, extras) {
+  const warning = formatExtraAvailableModelsWarning(source, extras);
+  if (warning) console.error(warning);
+}
+
 /**
  * Backup sentinel recorded when the settings file did NOT exist before the
  * first `setup`. A re-run then finds a backup already present (so it won't
@@ -338,8 +514,19 @@ export async function setup({
 
   const { apiKey, apiUrl } = await resolveCredentials({ modeFlag });
   const env = buildClaudeEnv({ apiUrl, apiKey, model, backgroundModel });
+  // The commit-attribution trailer names the resolved startup model (mirrors
+  // buildClaudeEnv's `main` resolution) so a non-default --model setup isn't
+  // misattributed to GLM-5.2.
+  const mainModel = model || DEFAULT_MODEL;
 
   const { settings, existed } = readSettings(filePath);
+  const extraModelWarningSources = extraAvailableModelWarningSources({
+    scope,
+    filePath,
+    settings,
+    mainModel,
+    backgroundModel: backgroundModel || mainModel,
+  });
   // Create the settings dir before writing the backup/sentinel. On a fresh
   // machine (no ~/.claude, or a brand-new CLAUDE_CONFIG_DIR) the sentinel write
   // below would otherwise ENOENT — after the key was already minted — since
@@ -371,6 +558,8 @@ export async function setup({
   }
 
   const removedKeys = mergeSailEnv(settings, env, { scope });
+  mergeAttribution(settings, mainModel);
+  mergeModelPickerSettings(settings, mainModel, backgroundModel || mainModel);
   writeSettings(filePath, settings, { containsSecret: true });
 
   if (removedKeys.length > 0) {
@@ -398,6 +587,9 @@ export async function setup({
         "them in your shell profile.",
     );
   }
+  for (const { source, extras } of extraModelWarningSources) {
+    warnExtraAvailableModels(source, extras);
+  }
 
   const revertCmd =
     "sail-code setup --revert" + (scope === "project" ? " --project" : "");
@@ -424,6 +616,12 @@ export async function setup({
       reach +
       " Undo anytime with: " +
       revertCmd +
+      "\n" +
+      "Also set `attribution.commit` to a Sail co-author trailer naming the " +
+      "resolved model (" +
+      sailCommitTrailer(mainModel) +
+      ") so commits the agent makes are attributed to the Sail-served model " +
+      "(--revert restores your original attribution)." +
       "\n\nVS Code note: the extension reads this file for its sessions, but " +
       "its own pre-launch login check does not — if you have no saved " +
       "Anthropic login, also add these to VS Code's user settings " +
@@ -462,6 +660,7 @@ export function revert({ scope = "user" }) {
     console.error(`Nothing to revert: ${filePath} does not exist.`);
     return 0;
   }
+  const shouldStripModelPicker = isSailGeneratedModelPickerSettings(settings);
   if (settings.env && typeof settings.env === "object") {
     for (const key of OWNED_ENV_KEYS) delete settings.env[key];
     // Clear the falsy overrides a project-scope setup wrote, but only when
@@ -472,8 +671,40 @@ export function revert({ scope = "user" }) {
     ]) {
       if (settings.env[key] === "") delete settings.env[key];
     }
+    delete settings.env[MANAGED_MODEL_PICKER_ENV_KEY];
     if (Object.keys(settings.env).length === 0) delete settings.env;
   }
+  // Remove the Sail commit attribution, but only where the value still matches
+  // a trailer we can recognize as ours — a value the user replaced after setup
+  // is theirs, not ours (mirrors the empty-override logic above). Drop the
+  // attribution block if it becomes empty. Unrelated attribution keys (e.g.
+  // sessionUrl) are preserved.
+  //
+  // We match only the DEFAULT-model trailer ("GLM-5.2 via Sail") here: revert
+  // doesn't know which model setup used (it has no --model flag and no record of
+  // the setup-time choice), so a custom-`--model` trailer can't be reliably
+  // reconstructed. Leaving a custom-model trailer in place on this fallback path
+  // is the conservative choice (don't clobber something we can't identify as
+  // ours); the byte-backup revert path restores the original verbatim, so this
+  // only matters when the backup is gone — re-run `setup` then `--revert` to
+  // clear a custom-model trailer.
+  //
+  // `pr` is intentionally NOT stripped on this no-backup path: Claude Code
+  // documents `pr: ""` as the normal setting for disabling PR attribution, so an
+  // empty `pr` is meaningful user configuration indistinguishable from what we
+  // write. The byte-backup revert path restores the original `pr` verbatim.
+  if (settings.attribution && typeof settings.attribution === "object") {
+    if (settings.attribution.commit === sailCommitTrailer(DEFAULT_MODEL)) {
+      delete settings.attribution.commit;
+    }
+    if (Object.keys(settings.attribution).length === 0) {
+      delete settings.attribution;
+    }
+  }
+  if (shouldStripModelPicker) {
+    delete settings.availableModels;
+    delete settings.enforceAvailableModels;
+  }
   writeSettings(filePath, settings);
   console.error(
     `Removed Sail routing keys from ${filePath} (no backup was present).`,