copillm 0.4.2 → 0.4.5

package/dist/cli/commands/daemon.js

@@ -20,7 +20,8 @@ import { writeCommandOutput, writeHealthOutput } from "../shared/output.js";
 import { spawnDetachedDaemon } from "../daemon/spawnDetached.js";
 import { resolveRestartDecision } from "../daemon/restart.js";
 import { selfUpdateToLatest, describeSelfUpdate } from "../daemon/selfUpdate.js";
-import { getPackageInfo } from "../packageInfo.js";
+import { computeVersionStatus } from "../daemon/versionStatus.js";
+import { getPackageInfo } from "../../config/packageInfo.js";
 export function register(program) {
     program
         .command("start")
@@ -267,11 +268,13 @@ export function register(program) {
         .command("status")
         .description("Show daemon status")
         .option("--json", "JSON output")
+        .option("--no-registry-check", "Skip the npm registry lookup for latest-version comparison (also via NO_UPDATE_NOTIFIER / COPILLM_UPDATE_CHECK=0)")
         .action(async (opts) => {
         const config = loadConfig();
         const lockState = inspectLock();
         const checkedAtIso = new Date().toISOString();
         const uptimeSeconds = lockState.state === "running" ? computeUptimeSeconds(lockState.lock.started_at_iso) : null;
+        const cliPackageInfo = getPackageInfo();
         // inspectStoredCredential never returns the token itself, so it's safe to
         // include the result in the status payload.
         let authInfo;
@@ -303,6 +306,16 @@ export function register(program) {
             health_state: null,
             health_error: null,
             health_status: "unknown",
+            // Version reporting — populated below. cli_version is always known
+            // (read from this CLI binary). daemon_version is `null` until the
+            // /healthz probe completes; older daemons (predating the field) also
+            // report null. latest_version is best-effort and `null` if the
+            // registry lookup is skipped or fails.
+            daemon_version: null,
+            cli_version: cliPackageInfo.version,
+            latest_version: null,
+            update_available: false,
+            version_hint: null,
             checked_at_iso: checkedAtIso,
             stale_reason: lockState.state === "stale" ? lockState.reason : null
         };
@@ -313,7 +326,19 @@ export function register(program) {
             status.health_check_status_code = health.statusCode;
             status.health_state = health.status;
             status.health_error = health.error;
+            status.daemon_version = health.version;
         }
+        // Commander turns `--no-registry-check` into `opts.registryCheck === false`.
+        const versionStatus = await computeVersionStatus({
+            cliPackageInfo,
+            daemonVersion: status.daemon_version,
+            daemonRunning: status.running,
+            noRegistryCheck: opts.registryCheck === false
+        });
+        status.daemon_version = versionStatus.daemon_version;
+        status.latest_version = versionStatus.latest_version;
+        status.update_available = versionStatus.update_available;
+        status.version_hint = versionStatus.hint;
         if (opts.json) {
             process.stdout.write(JSON.stringify(status, null, 2) + "\n");
             return;
@@ -332,6 +357,7 @@ export function register(program) {
                 process.stdout.write(` error=${status.health_error}`);
             }
             process.stdout.write("\n");
+            writeVersionLine(status);
             if (status.bearer_ttl_seconds !== null) {
                 process.stdout.write(`bearer_ttl_seconds: ${status.bearer_ttl_seconds}\n`);
             }
@@ -344,10 +370,12 @@ export function register(program) {
         }
         if (lockState.state === "stale") {
             process.stdout.write(`stale lock (${lockState.reason})\n`);
+            writeVersionLine(status);
             writeAuthStatusLine(authInfo);
             return;
         }
         process.stdout.write("not running\n");
+        writeVersionLine(status);
         writeAuthStatusLine(authInfo);
     });
     program
@@ -453,6 +481,37 @@ function toDaemonLockState(lockState) {
     }
     return { state: "missing" };
 }
+/**
+ * Render the `version: ...` line for `copillm status` human output.
+ *
+ * When the daemon is running and reports the same version as this CLI, the
+ * line is just `version: 0.4.3` — the common, boring case. Mismatches surface
+ * inline so users see immediately whether they need to restart (cli > daemon)
+ * or `npm install -g copillm` (latest > cli). When the daemon is stopped, the
+ * line only reports the CLI's version, since there is no live daemon version
+ * to compare against.
+ */
+function writeVersionLine(status) {
+    let line = "version: ";
+    if (status.running && status.daemon_version !== null) {
+        line += status.daemon_version;
+        if (status.daemon_version !== status.cli_version) {
+            line += ` (cli ${status.cli_version})`;
+        }
+    }
+    else if (status.running && status.daemon_version === null) {
+        // Either an older daemon that predates this field, or a malformed
+        // /healthz response. The version_hint below will prompt a restart.
+        line += `? (cli ${status.cli_version})`;
+    }
+    else {
+        line += `cli ${status.cli_version}`;
+    }
+    if (status.version_hint) {
+        line += ` — ${status.version_hint}`;
+    }
+    process.stdout.write(line + "\n");
+}
 /**
  * Load the shared credential/config/discovery context for `copillm start`'s
  * codex + pi init steps, ONLY when at least one of them is going to run.

package/dist/cli/daemon/probes.js

@@ -94,7 +94,8 @@ export async function probeHealth(port, options) {
                     statusCode: response.status,
                     status: typeof payload.status === "string" ? payload.status : null,
                     error: typeof payload.error === "string" ? payload.error : null,
-                    bearerTtlSeconds: response.ok && typeof payload.bearer_ttl_seconds === "number" ? payload.bearer_ttl_seconds : null
+                    bearerTtlSeconds: response.ok && typeof payload.bearer_ttl_seconds === "number" ? payload.bearer_ttl_seconds : null,
+                    version: typeof payload.version === "string" && payload.version.length > 0 ? payload.version : null
                 },
                 failed: false
             };
@@ -104,7 +105,7 @@ export async function probeHealth(port, options) {
         }
     }, options);
     return result.failed
-        ? { ok: false, bearerTtlSeconds: null, statusCode: null, status: null, error: "health_probe_failed" }
+        ? { ok: false, bearerTtlSeconds: null, statusCode: null, status: null, error: "health_probe_failed", version: null }
         : result.ok;
 }
 export async function readLiveLock() {

package/dist/cli/daemon/versionStatus.js

@@ -0,0 +1,63 @@
+import { fetchLatestNpmVersion, isNewerVersion, parseBooleanOverride } from "../updateNotifier.js";
+const DEFAULT_REGISTRY_TIMEOUT_MS = 1_500;
+/**
+ * Resolve the three version data points (daemon, cli, latest-on-npm) and
+ * compute the `copillm status` actionable hint from them. Pulled out of the
+ * status command so it stays unit-testable end-to-end without spinning up a
+ * real proxy.
+ *
+ * Opt-out precedence (any of these skips the npm lookup):
+ *   - `noRegistryCheck` argument (driven by the `--no-registry-check` flag)
+ *   - `NO_UPDATE_NOTIFIER` env (matches the update-notifier convention)
+ *   - `COPILLM_UPDATE_CHECK=0|false|no|off`
+ *
+ * The registry lookup itself is best-effort: timeouts / network errors
+ * silently yield `latest_version: null`. We do *not* surface a "registry
+ * unreachable" message in status — that would be more noise than signal for
+ * a daemon-status command.
+ */
+export async function computeVersionStatus(options) {
+    const env = options.env ?? process.env;
+    const cliVersion = options.cliPackageInfo.version;
+    const daemonVersion = options.daemonVersion;
+    const registryCheckDisabled = options.noRegistryCheck === true ||
+        "NO_UPDATE_NOTIFIER" in env ||
+        parseBooleanOverride(env.COPILLM_UPDATE_CHECK) === false;
+    let latestVersion = null;
+    if (!registryCheckDisabled) {
+        latestVersion = await fetchLatestNpmVersion(options.cliPackageInfo.name, {
+            fetchImpl: options.fetchImpl,
+            registryUrl: options.registryUrl ?? env.COPILLM_UPDATE_REGISTRY_URL,
+            timeoutMs: options.timeoutMs ?? DEFAULT_REGISTRY_TIMEOUT_MS
+        });
+    }
+    const daemonStale = options.daemonRunning && daemonVersion !== null && isNewerVersion(cliVersion, daemonVersion);
+    const cliStale = latestVersion !== null && isNewerVersion(latestVersion, cliVersion);
+    const daemonReportsNoVersion = options.daemonRunning && daemonVersion === null;
+    return {
+        daemon_version: daemonVersion,
+        cli_version: cliVersion,
+        latest_version: latestVersion,
+        update_available: daemonStale || cliStale,
+        hint: buildVersionHint({ daemonStale, cliStale, daemonReportsNoVersion, cliVersion, latestVersion })
+    };
+}
+/**
+ * Pure helper. Public for direct unit testing of the messaging matrix.
+ */
+export function buildVersionHint(input) {
+    const parts = [];
+    if (input.cliStale && input.latestVersion !== null) {
+        parts.push(`newer version available: v${input.latestVersion} (npm install -g copillm)`);
+    }
+    if (input.daemonStale) {
+        parts.push(`restart to apply cli v${input.cliVersion}`);
+    }
+    if (parts.length === 0 && input.daemonReportsNoVersion) {
+        return "restart to start reporting version";
+    }
+    if (parts.length === 0) {
+        return null;
+    }
+    return parts.join("; ");
+}

package/dist/cli/index.js

@@ -11,7 +11,7 @@ import * as piCmd from "./commands/agents/pi.js";
 import * as copilotCmd from "./commands/agents/copilot.js";
 import { setRootLogger, setRootProgram } from "./shared/debug.js";
 import { applyDevModeEnv } from "./shared/devMode.js";
-import { getPackageInfo } from "./packageInfo.js";
+import { getPackageInfo } from "../config/packageInfo.js";
 import { maybeNotifyAboutUpdate } from "./updateNotifier.js";
 const logger = createLogger();
 const program = new Command();

package/dist/cli/updateNotifier.js

@@ -67,6 +67,24 @@ export function distTagsUrl(packageName, registryUrl = DEFAULT_REGISTRY_URL) {
 export function isNewerVersion(candidate, current) {
     return compareSemver(candidate, current) > 0;
 }
+/**
+ * Parse `"1" | "true" | "yes" | "on"` → true, `"0" | "false" | "no" | "off"` → false,
+ * anything else → null. Exposed so the status command can mirror the
+ * `COPILLM_UPDATE_CHECK` opt-out semantics without re-implementing the parsing.
+ */
+export function parseBooleanOverride(value) {
+    if (value === undefined) {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(normalized)) {
+        return false;
+    }
+    return null;
+}
 function shouldRunUpdateCheck(opts) {
     if (opts.stderr.isTTY !== true)
         return false;
@@ -168,19 +186,6 @@ function notifyIfNewer(stderr, packageInfo, latestVersion) {
 function hasArg(argv, arg) {
     return argv.slice(2).includes(arg);
 }
-function parseBooleanOverride(value) {
-    if (value === undefined) {
-        return null;
-    }
-    const normalized = value.trim().toLowerCase();
-    if (["1", "true", "yes", "on"].includes(normalized)) {
-        return true;
-    }
-    if (["0", "false", "no", "off"].includes(normalized)) {
-        return false;
-    }
-    return null;
-}
 function isTruthyCi(value) {
     if (value === undefined) {
         return false;

package/dist/{cli → config}/packageInfo.js

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
 const FALLBACK_PACKAGE_INFO = {
     name: "copillm",
-    version: "0.4.2"
+    version: "0.4.5"
 };
 export function getPackageInfo() {
     const envName = cleanPackageValue(process.env.COPILLM_PACKAGE_NAME);

package/dist/models/anthropicDefaults.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import { z } from "zod";
 import { accountModelsCacheReadPath, modelsCacheReadPath } from "../config/home.js";
 import { assertValidAccountId } from "../config/accountId.js";
+import { toAnthropicSurfaceModelId } from "./claudeModelId.js";
 export const ANTHROPIC_FAMILIES = ["opus", "sonnet", "haiku"];
 const SUFFIX_BLOCKLIST = [
     "-high",
@@ -27,12 +28,20 @@ export function computeAnthropicDefaults(modelIds) {
             byFamily[family].push(id);
         }
     }
+    // The picked ids feed the ANTHROPIC_DEFAULT_{OPUS,SONNET,HAIKU}_MODEL env
+    // vars Claude Code reads, so they must be in Claude Code's dash-separated
+    // surface form (e.g. `claude-sonnet-4-6`). A dotted upstream id like
+    // `claude-sonnet-4.6` would canonicalise to the deprecated `claude-sonnet-4-0`
+    // inside Claude Code (see src/models/claudeModelId.ts).
     return {
-        opus: pickPlainLatest(byFamily.opus),
-        sonnet: pickPlainLatest(byFamily.sonnet),
-        haiku: pickPlainLatest(byFamily.haiku)
+        opus: toSurfaceModelId(pickPlainLatest(byFamily.opus)),
+        sonnet: toSurfaceModelId(pickPlainLatest(byFamily.sonnet)),
+        haiku: toSurfaceModelId(pickPlainLatest(byFamily.haiku))
     };
 }
+function toSurfaceModelId(modelId) {
+    return modelId === null ? null : toAnthropicSurfaceModelId(modelId);
+}
 export function readModelIdsFromCache(accountId) {
     let file;
     if (accountId === undefined) {

package/dist/models/claudeModelId.js

@@ -0,0 +1,64 @@
+/**
+ * Bidirectional mapping between the **upstream Copilot** Claude model id form
+ * and the form Claude Code's model registry expects.
+ *
+ * GitHub Copilot's catalog names Claude models with a dotted minor version:
+ *
+ *   claude-sonnet-4.6   claude-opus-4.8   claude-haiku-4.5
+ *
+ * Claude Code, however, keys its internal model registry on a dash-separated
+ * form (`claude-sonnet-4-6`) and carries a legacy canonicaliser that maps any
+ * unrecognised `claude-sonnet-4…` / `claude-opus-4…` string to the original,
+ * now-deprecated `claude-sonnet-4-0` / `claude-opus-4-0` (extracted from the
+ * Claude Code binary):
+ *
+ *   if (e.includes("claude-sonnet-4-6"))         return "claude-sonnet-4-6";
+ *   if (e.includes("claude-sonnet-4-5"))         return "claude-sonnet-4-5";
+ *   if (/claude-sonnet-4(?!-\d(?!\d))/.test(e))  return "claude-sonnet-4-0"; // deprecated
+ *   …same shape for opus…
+ *
+ * A dotted id like `claude-sonnet-4.6` slips past the specific `includes`
+ * checks (they look for a dash) and is caught by the loose regex, so Claude
+ * Code believes it is running the deprecated "Sonnet 4" — it injects
+ * `You are powered by the model named Sonnet 4` into the system prompt and
+ * shows a retirement warning. The dash-separated `claude-sonnet-4-6` is
+ * matched by the specific branch first and is not deprecated.
+ *
+ * So copillm advertises / exports the **dash** form to Claude Code, and
+ * rewrites it back to the **dotted** upstream form before forwarding a request
+ * to Copilot (which only accepts the dotted id — a dashed id returns upstream
+ * 400 `model_not_supported`).
+ *
+ * Both transforms are scoped to `claude-` ids and only touch the trailing
+ * `<major>.<minor>` / `<major>-<minor>` version segment, so they are exact
+ * inverses for every Copilot Claude id (each has a single trailing dotted
+ * version). Non-claude ids (gpt, gemini — the only ids with mid-string dots
+ * such as `gpt-5.3-codex`) are returned unchanged.
+ */
+const CLAUDE_ID_PREFIX = "claude-";
+function isClaudeId(modelId) {
+    return modelId.toLowerCase().startsWith(CLAUDE_ID_PREFIX);
+}
+/**
+ * Upstream (dotted) -> Claude Code surface (dashed).
+ * `claude-sonnet-4.6` -> `claude-sonnet-4-6`. No-op for non-claude ids and for
+ * ids without a trailing dotted version.
+ */
+export function toAnthropicSurfaceModelId(modelId) {
+    if (!isClaudeId(modelId)) {
+        return modelId;
+    }
+    return modelId.replace(/(\d)\.(\d+)$/, "$1-$2");
+}
+/**
+ * Claude Code surface (dashed) -> upstream (dotted).
+ * `claude-sonnet-4-6` -> `claude-sonnet-4.6`. No-op for non-claude ids and for
+ * ids whose trailing segment is not a `<digit>-<digits>` version (e.g. an
+ * already-dotted id passes through unchanged).
+ */
+export function toUpstreamModelId(modelId) {
+    if (!isClaudeId(modelId)) {
+        return modelId;
+    }
+    return modelId.replace(/(\d)-(\d+)$/, "$1.$2");
+}

package/dist/server/anthropicModelsResponse.js

@@ -1,3 +1,4 @@
+import { toAnthropicSurfaceModelId } from "../models/claudeModelId.js";
 /**
  * Claude Code's only client-side marker for a 1M-context-budget model is a
  * literal `[1m]` suffix on the model id (matched in its binary via
@@ -57,13 +58,18 @@ export function buildAnthropicModelsResponse(models) {
  * picker — a label that would imply 1M-class behaviour Claude Code would
  * never deliver for that vendor.
  *
+ * The base id is first mapped to Claude Code's dash-separated surface form
+ * (`claude-sonnet-4.6` -> `claude-sonnet-4-6`) via `toAnthropicSurfaceModelId`
+ * so the advertised id is not mistaken for the deprecated `claude-sonnet-4-0`
+ * (see src/models/claudeModelId.ts).
+ *
  * Models already carrying the suffix are left alone. Models below the 1M
  * threshold get no alias regardless of name — Claude Code has no
  * client-side marker for the 200K-1M intermediate range, and over-claiming
  * would set the wrong autocompact trigger.
  */
 export function applyOneMillionAlias(model) {
-    const baseId = typeof model.id === "string" ? model.id : "";
+    const baseId = toAnthropicSurfaceModelId(typeof model.id === "string" ? model.id : "");
     if (baseId.endsWith(ONE_M_ALIAS_SUFFIX)) {
         return baseId;
     }

package/dist/server/proxy.js

@@ -1,5 +1,6 @@
 import { createServer } from "node:http";
 import { randomUUID } from "node:crypto";
+import { getPackageInfo } from "../config/packageInfo.js";
 import { singleAccountResolver } from "./accountResolver.js";
 import { attachRequestLifecycle, isBenignSocketError, safeEnd, safeSendJson } from "./requestLifecycle.js";
 import { InvalidRequestShapeError, JsonRequestParseError, RequestBodyTooLargeError } from "./errors.js";
@@ -11,6 +12,7 @@ import { handleProxyForward } from "./routes/proxyForward.js";
 import { isLocalRequest, resolveRoute, safePathname } from "./routes/shared.js";
 export async function startProxyServer(input) {
     const debugEnabled = input.debug === true;
+    const packageVersion = getPackageInfo().version;
     const resolver = input.accountResolver ??
         singleAccountResolver({
             tokenManager: input.tokenManager,
@@ -57,10 +59,10 @@ export async function startProxyServer(input) {
             }
             switch (route.kind) {
                 case "livez":
-                    handleLivez(res);
+                    handleLivez(res, { version: packageVersion });
                     return;
                 case "healthz":
-                    await handleHealthz(res, resolver.default.tokenManager);
+                    await handleHealthz(res, resolver.default.tokenManager, { version: packageVersion });
                     return;
                 case "models":
                     await handleModels(res, route.kind, resolver.default);
@@ -86,7 +88,8 @@ export async function startProxyServer(input) {
                         tokenManager: resolver.default.tokenManager,
                         githubToken: resolver.default.githubToken,
                         port: input.port,
-                        accounts: resolver.describe()
+                        accounts: resolver.describe(),
+                        packageVersion
                     });
                     return;
                 case "not_found":

package/dist/server/routes/debug.js

@@ -35,6 +35,7 @@ export async function handleDebug(res, input) {
             port: input.port,
             pid: process.pid,
             node_version: process.version,
+            version: input.packageVersion ?? null,
             started_at_iso: DAEMON_STARTED_AT_ISO,
             uptime_seconds: uptimeSeconds,
             account_type: input.config.accountType,

package/dist/server/routes/health.js

@@ -1,17 +1,22 @@
 import { healthFailure } from "../errors.js";
 import { safeSendJson } from "../requestLifecycle.js";
 const HEALTH_REFRESH_THRESHOLD_SECONDS = 60;
-export function handleLivez(res) {
-    safeSendJson(res, 200, { status: "ok", uptime_seconds: Math.floor(process.uptime()) });
+export function handleLivez(res, meta) {
+    safeSendJson(res, 200, {
+        status: "ok",
+        uptime_seconds: Math.floor(process.uptime()),
+        version: meta.version
+    });
 }
-export async function handleHealthz(res, tokenManager) {
+export async function handleHealthz(res, tokenManager, meta) {
     const ttl = tokenManager.expiresInSeconds();
     if (ttl !== null && ttl > HEALTH_REFRESH_THRESHOLD_SECONDS) {
         safeSendJson(res, 200, {
             status: "ok",
             token_state: "fresh",
             refresh_threshold_seconds: HEALTH_REFRESH_THRESHOLD_SECONDS,
-            bearer_ttl_seconds: ttl
+            bearer_ttl_seconds: ttl,
+            version: meta.version
         });
         return;
     }
@@ -22,11 +27,12 @@ export async function handleHealthz(res, tokenManager) {
             status: "ok",
             token_state: "refreshed",
             refresh_threshold_seconds: HEALTH_REFRESH_THRESHOLD_SECONDS,
-            bearer_ttl_seconds: refreshedTtl
+            bearer_ttl_seconds: refreshedTtl,
+            version: meta.version
         });
     }
     catch (error) {
         const failed = healthFailure(error);
-        safeSendJson(res, failed.httpStatus, failed.payload);
+        safeSendJson(res, failed.httpStatus, { ...failed.payload, version: meta.version });
     }
 }

package/dist/server/routes/proxyForward.js

@@ -1,4 +1,5 @@
 import { resolveModelId } from "../../models/discovery.js";
+import { toUpstreamModelId } from "../../models/claudeModelId.js";
 import { CopilotTokenManagerError } from "../../auth/copilotToken.js";
 import { anthropicToOpenAI, ProtocolTranslationError } from "../../translation/openaiAnthropic.js";
 import { writeAnthropicPrelude } from "../../translation/streamingOpenAIToAnthropic.js";
@@ -52,7 +53,14 @@ export async function handleProxyForward(input) {
         });
         return;
     }
-    const upstreamBody = resolvedModel ? rewriteRequestedModel(translatedBody, resolvedModel.id) : translatedBody;
+    // Claude Code talks to copillm in its dash-separated surface form
+    // (`claude-sonnet-4-6`); upstream Copilot only accepts the dotted id
+    // (`claude-sonnet-4.6`). Rewrite back before forwarding. A local model
+    // selection already resolves to the dotted catalog id, so only the
+    // unfiltered anthropic path needs the explicit conversion.
+    const upstreamModelId = resolvedModel?.id ??
+        (requestedModel && route.kind === "anthropic" ? toUpstreamModelId(requestedModel) : null);
+    const upstreamBody = upstreamModelId ? rewriteRequestedModel(translatedBody, upstreamModelId) : translatedBody;
     const upstreamPath = route.kind === "codex_responses" ? "/responses" : "/chat/completions";
     const isAnthropicStreaming = route.anthroShape && isStreamingRequestBody(translatedBody);
     let prelude = null;

package/dist/server/upstream/streaming.js

@@ -101,6 +101,13 @@ export async function forwardResponse(upstream, anthroShape, res, diagnostics) {
             }
             throw error;
         }
+        // Echo back the model id the client requested (Claude Code's dash-separated
+        // surface id) rather than the dotted id upstream returns, so Claude Code
+        // does not re-canonicalise the response model to the deprecated
+        // claude-…-4-0. Streaming already does this via the prelude fallbackModel.
+        if (diagnostics.requestedModel && payload && typeof payload === "object") {
+            payload.model = diagnostics.requestedModel;
+        }
     }
     safeSendJson(res, 200, payload);
 }

package/dist/translation/openaiAnthropic.js

@@ -153,7 +153,7 @@ function translateSystemToText(system) {
     return joinTextBlocks(system, "Anthropic system prompt");
 }
 function translateAnthropicMessage(message) {
-    if (message.role !== "assistant" && message.role !== "user") {
+    if (message.role !== "assistant" && message.role !== "user" && message.role !== "system") {
         throw new ProtocolTranslationError("unsupported_message_role", `Unsupported Anthropic message role: ${String(message.role)}.`);
     }
     if (typeof message.content === "string") {
@@ -162,6 +162,16 @@ function translateAnthropicMessage(message) {
     if (!Array.isArray(message.content)) {
         throw new ProtocolTranslationError("invalid_message_content", "Anthropic message content must be a string or array.");
     }
+    if (message.role === "system") {
+        // Claude Code's "mid-conversation system message" feature (a beta it turns on
+        // for correctly-recognised current models, e.g. Opus 4.8) places role:"system"
+        // entries inside `messages`, not just the top-level `system` field. Anthropic's
+        // own API only accepts system at the top level, but copillm translates to
+        // OpenAI chat/completions, which supports system-role messages natively — so
+        // map it through instead of 400ing. A 400 here surfaces to the user as a hard
+        // API error rather than triggering Claude Code's <system-reminder> fallback.
+        return [{ role: "system", content: joinTextBlocks(message.content, "Anthropic system message") }];
+    }
     return message.role === "assistant"
         ? translateAssistantMessageBlocks(message.content)
         : translateUserMessageBlocks(message.content);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copillm",
-  "version": "0.4.2",
+  "version": "0.4.5",
   "description": "Local Copilot proxy CLI (OpenAI/Anthropic-compatible)",
   "license": "MIT",
   "type": "module",
@@ -29,6 +29,8 @@
     "dev:start": "npm run build && node dist/cli.js --dev start",
     "dev:stop": "npm run build && node dist/cli.js --dev stop",
     "dev:status": "node dist/cli.js --dev status",
+    "dev:link": "node scripts/dev-link.mjs",
+    "dev:unlink": "node scripts/dev-unlink.mjs",
     "lint": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.tests.json --noEmit && eslint src",
     "lint:boundaries": "eslint src",
     "test": "vitest run",