Release v202611-00009

On x86_64 the dynamic loader lives in /lib64, so the probe failed with
"execvp /bin/true: No such file or directory" and shell commands of non-admin
users were disabled on amd64 hosts. The sandbox itself already mounted it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

CHANGELOG.md

@@ -3,6 +3,30 @@
 All notable changes to CodeCraft. Versions follow [Semantic Versioning](https://semver.org/);
 until 1.0, minor versions may contain breaking changes.
 
+## [v202611-00009] – 2026-11-09
+
+### Fixed
+
+- **Sandbox on x86_64:** the start-up check of bubblewrap did not mount `/lib64`, so it failed
+  on amd64 hosts and shell commands of non-admin users were disabled.
+
+## [v202611-00008] – 2026-11-09
+
+### Added
+
+- **Instructions per chat:** *⋯ → Instructions for this chat* (Telegram: `/prompt`) sets rules
+  that apply to every message of that chat on top of the mode – language, tone, the part of the
+  project to work on. A chip in the header shows when a chat has them; forks keep them.
+
+### Fixed
+
+- OpenAI-compatible providers: tool results no longer carry a `name` field. Gateways that
+  translate to Anthropic (opencode) rejected the request with "anthropic-messages cannot
+  preserve named conversation participants".
+- Telegram: the token field is no longer filled in by the browser's password manager, the bot
+  token is found in whatever is pasted (also the whole BotFather message), and a wrong format
+  gets a clear message instead of "HTTP 404".
+
 ## [v202611-00007] – 2026-11-09
 
 ### Added

README.md

@@ -11,7 +11,7 @@
 </p>
 
 <p align="center">
-  <img alt="Version v202611-00007" src="https://img.shields.io/badge/version-v202611--00007-d69e2e?style=flat-square">
+  <img alt="Version v202611-00009" src="https://img.shields.io/badge/version-v202611--00009-d69e2e?style=flat-square">
   <img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-689d6a?style=flat-square">
   <img alt="Rust backend" src="https://img.shields.io/badge/backend-Rust-b7410e?style=flat-square&logo=rust">
   <img alt="React PWA" src="https://img.shields.io/badge/frontend-React%20PWA-2d81ff?style=flat-square&logo=react">

core/src/provider/openai.rs

@@ -47,10 +47,13 @@ pub fn to_wire_messages(system: &str, messages: &[Message]) -> Vec<Value> {
                         Part::Image { image } => parts.push(json!({
                             "type": "image_url", "image_url": {"url": data_url(image)}
                         })),
-                        Part::ToolResult { call_id, name, content, images, is_error, .. } => {
+                        Part::ToolResult { call_id, content, images, is_error, .. } => {
                             let text = if *is_error { format!("ERROR: {content}") } else { content.clone() };
+                            // No "name": it is not part of the tool message in the Chat
+                            // Completions API, and gateways that translate to Anthropic
+                            // (opencode) reject named participants.
                             out.push(json!({
-                                "role": "tool", "tool_call_id": call_id, "name": name,
+                                "role": "tool", "tool_call_id": call_id,
                                 "content": if text.is_empty() { "(no output)".into() } else { text }
                             }));
                             tool_images.extend(images.iter().cloned());
@@ -328,6 +331,22 @@ mod tests {
         (text, reasoning)
     }
 
+    #[test]
+    fn tool_messages_have_no_name() {
+        use crate::types::{Message, Part, Role};
+        let call = Part::ToolCall { id: "c1".into(), name: "bash".into(), input: serde_json::json!({"command": "ls"}), extra: None };
+        let result = Part::ToolResult { call_id: "c1".into(), name: "bash".into(), content: "ok".into(), images: vec![], is_error: false, meta: None };
+        let msgs = vec![
+            Message::new(Role::User, vec![Part::Text { text: "hi".into() }]),
+            Message::new(Role::Assistant, vec![call]),
+            Message::new(Role::User, vec![result]),
+        ];
+        let wire = super::to_wire_messages("sys", &msgs);
+        let tool = wire.iter().find(|m| m["role"] == "tool").expect("tool message");
+        assert_eq!(tool["tool_call_id"], "c1");
+        assert!(wire.iter().all(|m| m.get("name").is_none()), "no message may carry a name: {wire:?}");
+    }
+
     #[test]
     fn splits_think_tags_across_chunks() {
         let (text, reasoning) = run(&["<thi", "nk>plan ", "the fix</th", "ink>Here is ", "the answer."]);

core/src/types.rs

@@ -166,6 +166,9 @@ pub struct Session {
     /// User-defined group in the session list.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub folder: Option<String>,
+    /// Instructions the user set for this chat; added to the system prompt of every turn.
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub instructions: String,
 }
 
 impl Session {

scripts/deploy.sh

@@ -0,0 +1,117 @@
+#!/usr/bin/env bash
+# Roll out a published CodeCraft image to a remote installation that was set up with
+# scripts/move-server.sh (docker-compose.yml + .env in one folder on the target).
+#
+#   scripts/release.sh        # build and publish a new version (amd64 + arm64)
+#   scripts/deploy.sh         # roll the newest tag out to the target
+#
+# Steps:
+#   1. check that the image exists in the registry for the target's architecture,
+#   2. wait until no agent or terminal runs on the target (unless --force),
+#   3. set CODECRAFT_VERSION in the target's .env, docker compose pull && up -d
+#      (or start.sh on hosts without Compose),
+#   4. run scripts/smoke-test.sh on the target; on failure the previous version is
+#      started again.
+#
+# Usage: scripts/deploy.sh [vYYYYMM-NNNNN] [--target user@host:/dir] [--force]
+#                          [--wait MINUTES] [--dry-run]
+#   vYYYYMM-NNNNN   version to deploy (default: the newest vYYYYMM-NNNNN git tag)
+#   --target        installation folder on the target (default: DEPLOY_TARGET from .env)
+#   --force         restart even if agents or terminals are running (they end)
+#   --wait N        how long to wait for an idle server before giving up (default 15)
+#   --dry-run       show the steps only
+#
+# Environment:
+#   REGISTRY        image name without tag (default git.familie-zink.org/zink/codecraft)
+#   CONTAINER       container name on the target (default codecraft)
+#   PORT            port of CodeCraft on the target, for the smoke test (default: PORT
+#                   from the target's .env, else 8787)
+set -euo pipefail
+
+REGISTRY="${REGISTRY:-git.familie-zink.org/zink/codecraft}"
+CONTAINER="${CONTAINER:-codecraft}"
+
+tag="" target="" force=0 wait_min=15 dry=0
+while (($#)); do
+  case "$1" in
+    --target) target="$2"; shift ;;
+    --force) force=1 ;;
+    --wait) wait_min="$2"; shift ;;
+    --dry-run) dry=1 ;;
+    -h|--help) sed -n '2,29p' "$0"; exit 0 ;;
+    -*) echo "unknown option $1" >&2; exit 2 ;;
+    *) tag="$1" ;;
+  esac
+  shift
+done
+
+cd "$(git rev-parse --show-toplevel)"
+step() { printf '\n==> %s\n' "$*"; }
+fail() { echo "error: $*" >&2; exit 1; }
+q() { printf '%q' "$1"; }
+env_get() { [[ -f .env ]] && sed -n "s/^$1=//p" .env | tail -1 | sed -E "s/^'(.*)'\$/\1/; s/^\"(.*)\"\$/\1/"; }
+
+target="${target:-$(env_get DEPLOY_TARGET || true)}"
+[[ "$target" == *:/* ]] || fail "no target – pass --target user@host:/dir or set DEPLOY_TARGET in .env"
+host="${target%%:*}"
+dir="${target#*:}"; dir="${dir%/}"
+remote() { ssh -o BatchMode=yes "$host" "$1"; }
+run_remote() { if (( dry )); then echo "[dry-run] on $host: $1"; else remote "$1"; fi; }
+
+if [[ -z "$tag" ]]; then
+  git fetch --tags --quiet origin || true
+  tag=$(git tag -l 'v[0-9][0-9][0-9][0-9][0-9][0-9]-[0-9][0-9][0-9][0-9][0-9]' | sort | tail -1)
+  [[ -n "$tag" ]] || fail "no release tag found"
+fi
+[[ "$tag" =~ ^v[0-9]{6}-[0-9]{5}$ ]] || fail "version must look like vYYYYMM-NNNNN, got $tag"
+
+step "Checking $host:$dir and the image $REGISTRY:$tag"
+remote "test -f $(q "$dir/.env") && test -f $(q "$dir/docker-compose.yml")" \
+  || fail "$dir on $host has no .env/docker-compose.yml – set it up with scripts/move-server.sh"
+current=$(remote "sed -n 's/^CODECRAFT_VERSION=//p' $(q "$dir/.env") | tail -1")
+case "$(remote 'uname -m')" in
+  x86_64) arch=amd64 ;; aarch64|arm64) arch=arm64 ;; *) arch="" ;;
+esac
+if [[ -n "$arch" ]]; then
+  docker buildx imagetools inspect "$REGISTRY:$tag" 2>/dev/null | grep -q "Platform:.*linux/$arch" \
+    || fail "$REGISTRY:$tag has no linux/$arch image – run scripts/release.sh first"
+fi
+echo "deploying $tag (running: ${current:-unknown}, target linux/${arch:-?})"
+[[ "$current" == "$tag" ]] && echo "note: $tag is already configured – the container is recreated anyway"
+
+# Busy = the container runs more than the server process (agents' shells, terminals, ...).
+busy() { (( $(remote "docker top $(q "$CONTAINER") -o pid 2>/dev/null | tail -n +2 | wc -l") > 1 )); }
+if (( ! force )) && remote "docker inspect -f '{{.State.Running}}' $(q "$CONTAINER") 2>/dev/null" | grep -q true; then
+  step "Waiting until no agent or terminal runs (up to $wait_min min, --force skips this)"
+  deadline=$(( $(date +%s) + wait_min * 60 ))
+  while busy; do
+    (( $(date +%s) < deadline )) || fail "still busy after $wait_min min – try later or use --force"
+    sleep 15
+  done
+  echo "idle"
+fi
+
+step "Updating to $tag"
+run_remote "cd $(q "$dir") && sed -i 's/^CODECRAFT_VERSION=.*/CODECRAFT_VERSION=$tag/' .env \
+  && (grep -q '^CODECRAFT_VERSION=' .env || echo 'CODECRAFT_VERSION=$tag' >> .env) \
+  && docker pull -q $(q "$REGISTRY:$tag") >/dev/null \
+  && if docker compose version >/dev/null 2>&1; then docker compose up -d; else ./start.sh; fi"
+
+step "Smoke test"
+port="${PORT:-$(remote "sed -n 's/^PORT=//p' $(q "$dir/.env") | tail -1")}"; port="${port:-8787}"
+if (( dry )); then
+  echo "[dry-run] smoke test on $host: http://127.0.0.1:$port ${tag#v}"
+else
+  ssh -o BatchMode=yes "$host" "cat > $(q "$dir/smoke-test.sh")" <scripts/smoke-test.sh
+  if ! remote "bash $(q "$dir/smoke-test.sh") http://127.0.0.1:$port ${tag#v}"; then
+    if [[ -n "$current" && "$current" != "$tag" ]]; then
+      echo "smoke test failed – going back to $current" >&2
+      remote "cd $(q "$dir") && sed -i 's/^CODECRAFT_VERSION=.*/CODECRAFT_VERSION=$current/' .env \
+        && if docker compose version >/dev/null 2>&1; then docker compose up -d; else ./start.sh; fi"
+    fi
+    fail "deploy of $tag failed"
+  fi
+fi
+
+step "Done"
+echo "$host runs CodeCraft $tag."

scripts/move-server.sh

@@ -37,12 +37,15 @@
 #   --source-container C container to stop here (default codecraft)
 #   --source-volume V    data volume here (default codecraft-data)
 #   --source-workspace D project folder here (default: WORKSPACE of .env)
+#   --exclude PATTERN    leave this out of the workspace copy (rsync pattern, relative to the
+#                        workspace, e.g. /old-project/ or /app/target/); repeatable
 #   --no-stop            do not stop the source (only for tests – the copy may be inconsistent)
 #   --dry-run            show the steps only
 set -euo pipefail
 
 target="" ws_target="" tools_dir="" docker_sock=0 uid="" gid="" port="" bind="" name="codecraft"
 src_container="codecraft" src_volume="codecraft-data" ws_source="" stop=1 dry=0
+excludes=()
 while (($#)); do
   case "$1" in
     --workspace) ws_target="$2"; shift ;;
@@ -56,9 +59,10 @@ while (($#)); do
     --source-container) src_container="$2"; shift ;;
     --source-volume) src_volume="$2"; shift ;;
     --source-workspace) ws_source="$2"; shift ;;
+    --exclude) excludes+=(--exclude "$2"); shift ;;
     --no-stop) stop=0 ;;
     --dry-run) dry=1 ;;
-    -h|--help) sed -n '2,36p' "$0"; exit 0 ;;
+    -h|--help) sed -n '2,38p' "$0"; exit 0 ;;
     -*) echo "unknown option $1" >&2; exit 2 ;;
     *) target="$1" ;;
   esac
@@ -68,7 +72,8 @@ done
 
 cd "$(git rev-parse --show-toplevel)"
 [[ -f .env ]] || { echo "no .env in $(pwd)" >&2; exit 1; }
-env_get() { sed -n "s/^$1=//p" .env | tail -1; }
+# Value of a .env variable, without surrounding quotes.
+env_get() { sed -n "s/^$1=//p" .env | tail -1 | sed -E "s/^'(.*)'\$/\1/; s/^\"(.*)\"\$/\1/"; }
 
 host="${target%%:*}"
 dir="${target#*:}"
@@ -93,9 +98,9 @@ remote() {
 }
 q() { printf '%q' "$1"; }
 sync_workspace() {
-  if (( dry )); then echo "[dry-run] rsync $ws_source/ -> $host:$ws_target/"; return; fi
-  if [[ "$host" == local ]]; then rsync -a --numeric-ids "$ws_source/" "$ws_target/"
-  else rsync -a --numeric-ids -e "ssh -o BatchMode=yes" "$ws_source/" "$host:$ws_target/"; fi
+  if (( dry )); then echo "[dry-run] rsync ${excludes[*]} $ws_source/ -> $host:$ws_target/"; return; fi
+  if [[ "$host" == local ]]; then rsync -a --numeric-ids "${excludes[@]}" "$ws_source/" "$ws_target/"
+  else rsync -a --numeric-ids "${excludes[@]}" -e "ssh -o BatchMode=yes" "$ws_source/" "$host:$ws_target/"; fi
 }
 put_file() { # put_file <remote path> < content
   if (( dry )); then echo "[dry-run] write $host:$1"; cat >/dev/null; return; fi

server/src/api.rs

@@ -574,6 +574,7 @@ async fn create_session(Extension(user): Extension<User>, State(app): State<AppS
         pinned: false,
         archived: false,
         folder: None,
+        instructions: String::new(),
     };
     let s = app.save_session(s)?;
     Ok(Json(json!(s)))
@@ -782,12 +783,17 @@ struct UpdateSession {
     archived: Option<bool>,
     /// "" removes the folder.
     folder: Option<String>,
+    /// Instructions for this chat ("" clears them).
+    instructions: Option<String>,
 }
 
 async fn update_session(Extension(user): Extension<User>, State(app): State<AppState>, Path(id): Path<String>, Json(body): Json<UpdateSession>) -> ApiResult {
     writable(&app, &user, &id)?;
     // Organising the list must not move the session to "today".
-    let organise_only = body.title.is_none() && body.model.is_none() && body.agent.is_none() && body.clean_room.is_none() && body.permission_mode.is_none();
+    let organise_only = body.title.is_none() && body.model.is_none() && body.agent.is_none() && body.clean_room.is_none() && body.permission_mode.is_none() && body.instructions.is_none();
+    if body.instructions.as_ref().is_some_and(|i| i.len() > 20_000) {
+        return Err(ApiError(StatusCode::BAD_REQUEST, "instructions too long (max 20,000 characters)".into()));
+    }
     if let Some(m) = &body.model {
         app.registry().resolve(m)?;
     }
@@ -824,6 +830,9 @@ async fn update_session(Extension(user): Extension<User>, State(app): State<AppS
         if let Some(p) = body.permission_mode {
             s.permission_mode = p;
         }
+        if let Some(i) = body.instructions {
+            s.instructions = i.trim().to_string();
+        }
     })?;
     Ok(Json(json!(s)))
 }

server/src/jobs.rs

@@ -164,6 +164,7 @@ pub async fn run_with(app: &Arc<App>, job: &Job, trigger: &str, payload: Option<
         pinned: false,
         archived: false,
         folder: None,
+        instructions: String::new(),
     };
     let session = app.save_session(session)?;
     app.store.job_started(&job.id, &session.id, now)?;

server/src/prompts.rs

@@ -216,6 +216,17 @@ fn instruction_files(app: &App, root: &Path, cwd: &Path) -> Vec<(PathBuf, String
 
 /// The plain chat mode: no coding instructions, project files or memory – only the
 /// date, the model and what the user keeps in their personal memory.
+/// Add the instructions the user set for this chat (they come last, so they win).
+pub fn with_chat_instructions(mut system: String, instructions: &str) -> String {
+    if !instructions.trim().is_empty() {
+        system.push_str(&format!(
+            "\n\n# Instructions for this chat\nThe user set these for this chat. They apply to every message and override the defaults above:\n{}\n",
+            instructions.trim()
+        ));
+    }
+    system
+}
+
 fn chat_prompt(app: &App, agent: &Agent, model: &str, owner: Option<&crate::store::User>) -> String {
     let mut s = agent.prompt.clone();
     s.push_str(&format!("\n\n# Context\n- Date: {}\n- Model: {model}\n", chrono::Local::now().format("%A, %Y-%m-%d")));

server/src/runner.rs

@@ -293,7 +293,7 @@ pub async fn run_session(app: Arc<App>, session_id: &str, cancel: CancellationTo
         let tools = available_tools(&app, &agent, owner.as_ref());
         let history = active_history(app.store.messages(session_id)?);
         let req = ChatRequest {
-            system: prompts::system_prompt(&app, &agent, &root, &cwd, &model_spec, &session.permission_mode, owner.as_ref()),
+            system: prompts::with_chat_instructions(prompts::system_prompt(&app, &agent, &root, &cwd, &model_spec, &session.permission_mode, owner.as_ref()), &session.instructions),
             messages: history,
             tools: tools.iter().map(|t| t.def()).collect(),
             max_tokens: model.max_output.unwrap_or(16_000),
@@ -704,6 +704,7 @@ fn create_child(app: &Arc<App>, ctx: &ToolCtx, agent_name: &str, description: &s
         pinned: false,
         archived: false,
         folder: None,
+        instructions: String::new(),
     };
     let child = app.save_session(child)?;
     let msg = Message::new(Role::User, vec![Part::Text { text: prompt }]);

server/src/sandbox.rs

@@ -37,6 +37,8 @@ pub async fn probe() -> Result<(), String> {
     }
     let res = match Command::new("bwrap")
         .args(["--ro-bind", "/usr", "/usr", "--ro-bind", "/bin", "/bin", "--ro-bind", "/lib", "/lib", "--dev", "/dev", "--proc", "/proc"])
+        // The dynamic loader lives in /lib64 on x86_64 (/lib on arm64).
+        .args(["--ro-bind-try", "/lib64", "/lib64", "--ro-bind-try", "/lib32", "/lib32"])
         .args(["--unshare-all", "--die-with-parent", "--clearenv", "/bin/true"])
         .env_clear()
         .output()

server/src/telegram.rs

@@ -329,6 +329,7 @@ async fn handle_update(app: &Arc<App>, user_id: &str, bot: &Bot, u: &Value) -> R
                 return new_session(app, &u, bot, chat, &format!("{folder} {}", cur.agent), de).await;
             }
             "permissions" => return set_permissions(app, &u, bot, chat, arg, de).await,
+            "prompt" => return chat_instructions(app, &u, bot, chat, arg, de).await,
             "effort" => return set_effort(app, &u, bot, chat, arg, de).await,
             "costs" => return costs(app, &u, bot, chat, de).await,
             "memory" => return memory(app, &u, bot, chat, de).await,
@@ -401,13 +402,13 @@ fn help(de: bool) -> String {
     if de {
         "<b>CodeCraft</b> – Nachrichten gehen an die aktuelle Sitzung (Fotos und Dateien auch).\n\n\
          /sessions – letzte Sitzungen\n/session &lt;Nr|Name&gt; – Sitzung wechseln\n/new [Ordner] [Modus] – neue Sitzung (ohne Ordner: Chat)\n\
-         /clear – neue Sitzung im gleichen Ordner\n/mode [Name] – Modus\n/model [Modell] – Modell\n/permissions [Modus] – Freigaben\n/effort [Stufe] – Denktiefe\n\
+         /clear – neue Sitzung im gleichen Ordner\n/mode [Name] – Modus\n/model [Modell] – Modell\n/permissions [Modus] – Freigaben\n/prompt [Text|-] – Anweisungen für diesen Chat\n/effort [Stufe] – Denktiefe\n\
          /stop – Runde abbrechen\n/status – aktuelle Sitzung\n/costs – Kosten und Budgets\n/memory – Gedächtnis\n/jobs – Automationen\n/compact – Unterhaltung komprimieren"
             .into()
     } else {
         "<b>CodeCraft</b> – messages go to the current session (photos and files too).\n\n\
          /sessions – recent sessions\n/session &lt;n|name&gt; – switch session\n/new [folder] [mode] – new session (no folder: chat)\n\
-         /clear – new session in the same folder\n/mode [name] – mode\n/model [model] – model\n/permissions [mode] – approvals\n/effort [level] – reasoning effort\n\
+         /clear – new session in the same folder\n/mode [name] – mode\n/model [model] – model\n/permissions [mode] – approvals\n/prompt [text|-] – instructions for this chat\n/effort [level] – reasoning effort\n\
          /stop – stop the turn\n/status – current session\n/costs – costs and budgets\n/memory – memory\n/jobs – automations\n/compact – compact the conversation"
             .into()
     }
@@ -536,6 +537,7 @@ async fn new_session(app: &Arc<App>, u: &User, bot: &Bot, chat: i64, arg: &str,
         pinned: false,
         archived: false,
         folder: None,
+        instructions: String::new(),
     })?;
     update(app, &u.id, |st| st.session = Some(s.id.clone()));
     bot.send(chat, &format!("{} <b>{}</b> · {} · {}", tr(de, "Neue Sitzung", "New session"), esc(&s.cwd), esc(&s.agent), esc(&s.model)), None).await?;
@@ -620,6 +622,25 @@ async fn status_message(app: &App, u: &User, bot: &Bot, chat: i64, de: bool) ->
     Ok(())
 }
 
+/// Show, set ("/prompt text") or clear ("/prompt -") the instructions of the current chat.
+async fn chat_instructions(app: &App, u: &User, bot: &Bot, chat: i64, arg: &str, de: bool) -> Result<()> {
+    let s = current(app, u, de)?;
+    if arg.is_empty() {
+        let text = if s.instructions.is_empty() {
+            tr(de, "Keine Anweisungen für diesen Chat. Setzen mit /prompt &lt;Text&gt;.", "No instructions for this chat. Set them with /prompt &lt;text&gt;.").to_string()
+        } else {
+            format!("<b>{}</b>\n{}\n\n<i>{}</i>", tr(de, "Anweisungen für diesen Chat", "Instructions for this chat"), esc(&s.instructions), tr(de, "Löschen mit /prompt -", "Clear with /prompt -"))
+        };
+        bot.send(chat, &text, None).await?;
+        return Ok(());
+    }
+    let new = if arg == "-" { String::new() } else { arg.to_string() };
+    app.update_session(&s.id, |x| x.instructions = new.clone())?;
+    let text = if new.is_empty() { tr(de, "Anweisungen gelöscht.", "Instructions cleared.") } else { tr(de, "Anweisungen gesetzt – sie gelten ab der nächsten Nachricht.", "Instructions set – they apply from the next message.") };
+    bot.send(chat, text, None).await?;
+    Ok(())
+}
+
 const PERMISSION_MODES: &[&str] = &["auto", "default", "accept_edits", "bypass"];
 const EFFORTS: &[&str] = &["low", "medium", "high", "xhigh", "max"];
 

web/src/components/ChatView.tsx

@@ -13,6 +13,7 @@ import { useReasoningMode } from "../prefs";
 import { Composer } from "./Composer";
 import { ShareDialog } from "./ShareDialog";
 import { RenameDialog } from "./RenameDialog";
+import { InstructionsDialog } from "./InstructionsDialog";
 import { RegenerateButton } from "./Regenerate";
 import { WorktreeChip } from "./WorktreeChip";
 import { QueueList } from "./QueueList";
@@ -151,6 +152,7 @@ export function ChatView({ sessionId, onMenu, onClosePane }: { sessionId: string
   const isAdmin = useStore((s) => s.me?.role === "admin");
   const tabs = useChatTabs(sessionId, session?.cwd ?? "");
   const [sharing, setSharing] = useState(false);
+  const [editingInstructions, setEditingInstructions] = useState(false);
   const models = useModels();
   const [loadError, setLoadError] = useState<string>();
   const [text, setText] = useState(() => takePrefill(sessionId) ?? "");
@@ -307,6 +309,11 @@ export function ChatView({ sessionId, onMenu, onClosePane }: { sessionId: string
         <ShellsChip sessionId={sessionId} busy={busy} />
         {isAdmin && <BudgetChip />}
         {session.permission_mode === "bypass" && <span className="chip warn">{t("permissionMode.bypass")}</span>}
+        {!!session.instructions && (
+          <button className="chip" style={{ border: "none" }} onClick={() => !readOnly && setEditingInstructions(true)} title={session.instructions}>
+            <Icon name="edit" /> {t("instructions.chip")}
+          </button>
+        )}
         {readOnly && <span className="chip">{t("chat.readOnly")}</span>}
         {!readOnly && (
           <>
@@ -335,6 +342,16 @@ export function ChatView({ sessionId, onMenu, onClosePane }: { sessionId: string
                 <Icon name="more" />
               </summary>
               <div className="menu-pop-body">
+                <a
+                  href="#"
+                  onClick={(e) => {
+                    e.preventDefault();
+                    (e.currentTarget.closest("details") as HTMLDetailsElement).open = false;
+                    setEditingInstructions(true);
+                  }}
+                >
+                  <Icon name="edit" /> {t("instructions.title")}
+                </a>
                 <a href={`/api/sessions/${sessionId}/export?format=md`} download>
                   <Icon name="download" /> {t("chat.exportMd")}
                 </a>
@@ -527,6 +544,7 @@ export function ChatView({ sessionId, onMenu, onClosePane }: { sessionId: string
           </div>
         )}
       </div>
+      {editingInstructions && <InstructionsDialog sessionId={sessionId} value={session.instructions ?? ""} onClose={() => setEditingInstructions(false)} />}
       {editingTitle && <RenameDialog sessionId={sessionId} title={session.title} onClose={() => setEditingTitle(false)} />}
       {sharing && <ShareDialog sessionId={sessionId} onClose={() => setSharing(false)} />}
       {rewinding && <RewindDialog sessionId={sessionId} messageId={rewinding.id} onDone={rewindDone} onClose={() => setRewinding(undefined)} />}

web/src/components/InstructionsDialog.tsx

@@ -0,0 +1,55 @@
+import { useState } from "react";
+import { patch } from "../api";
+import { useT } from "../i18n";
+
+/** Instructions for one chat: added to the system prompt of every turn. */
+export function InstructionsDialog({ sessionId, value, onClose }: { sessionId: string; value: string; onClose: () => void }) {
+  const t = useT();
+  const [text, setText] = useState(value);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState<string>();
+
+  const save = async (next: string) => {
+    setBusy(true);
+    try {
+      await patch(`/sessions/${sessionId}`, { instructions: next });
+      onClose();
+    } catch (e: any) {
+      setError(e.message);
+      setBusy(false);
+    }
+  };
+
+  return (
+    <div className="modal-backdrop" onClick={onClose}>
+      <div className="modal instructions-modal" role="dialog" aria-label={t("instructions.title")} onClick={(e) => e.stopPropagation()}>
+        <h3>{t("instructions.title")}</h3>
+        <div className="hint" style={{ marginBottom: 8 }}>
+          {t("instructions.hint")}
+        </div>
+        <textarea
+          autoFocus
+          rows={10}
+          style={{ width: "100%" }}
+          value={text}
+          placeholder={t("instructions.placeholder")}
+          onChange={(e) => setText(e.target.value)}
+          onKeyDown={(e) => (e.ctrlKey || e.metaKey) && e.key === "Enter" && !busy && void save(text)}
+        />
+        {error && <div className="notice err">{error}</div>}
+        <div className="row" style={{ marginTop: 10, justifyContent: "flex-end", gap: 6 }}>
+          {value && (
+            <button className="danger" onClick={() => void save("")} disabled={busy}>
+              {t("instructions.clear")}
+            </button>
+          )}
+          <span className="spacer" />
+          <button onClick={onClose}>{t("common.cancel")}</button>
+          <button className="primary" onClick={() => void save(text)} disabled={busy || text.trim() === value.trim()}>
+            {t("common.save")}
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}

web/src/i18n/de.ts

@@ -593,6 +593,11 @@ export const de: Messages = {
   "chat.compactingAuto": "Kontext fast voll – Unterhaltung wird automatisch komprimiert",
   "chat.compactingManual": "Unterhaltung wird komprimiert",
   "chat.compactingDetail": "{tokens} von {limit} Tokens ({pct}) – danach arbeitet der Agent mit einer Zusammenfassung weiter",
+  "instructions.title": "Anweisungen für diesen Chat",
+  "instructions.hint": "Gelten für jede Nachricht in diesem Chat, zusätzlich zum Modus – z. B. Sprache, Ton, Regeln oder der Teil des Projekts, um den es geht.",
+  "instructions.placeholder": "z. B. Antworte immer auf Englisch. Ändere nur Dateien unter api/. Frag, bevor du Abhängigkeiten hinzufügst.",
+  "instructions.clear": "Entfernen",
+  "instructions.chip": "Anweisungen",
   "chat.compacted": "Unterhaltung komprimiert – Zusammenfassung",
   "chat.context": "Kontext",
   "chat.contextHint": "{tokens} Tokens in der letzten Anfrage",

web/src/i18n/en.ts

@@ -592,6 +592,11 @@ export const en = {
   "chat.compactingAuto": "Context nearly full – compacting the conversation automatically",
   "chat.compactingManual": "Compacting the conversation",
   "chat.compactingDetail": "{tokens} of {limit} tokens ({pct}) – the agent continues with a summary afterwards",
+  "instructions.title": "Instructions for this chat",
+  "instructions.hint": "Apply to every message in this chat, in addition to the mode – e.g. language, tone, rules, the part of the project to work on.",
+  "instructions.placeholder": "e.g. Always answer in English. Only change files under api/. Ask before adding dependencies.",
+  "instructions.clear": "Remove",
+  "instructions.chip": "Instructions",
   "chat.compacted": "Conversation compacted – summary",
   "chat.context": "Context",
   "chat.contextHint": "{tokens} tokens in the last request",

web/src/styles.css

@@ -3770,3 +3770,6 @@ span.chat-tab > button {
     display: none;
   }
 }
+.instructions-modal {
+  width: min(640px, calc(100vw - 32px));
+}

web/src/types.ts

@@ -67,6 +67,8 @@ export interface Session {
   pinned?: boolean;
   archived?: boolean;
   folder?: string | null;
+  /** Instructions for this chat (added to the system prompt). */
+  instructions?: string;
 }
 
 export interface QuestionOption {

web/src/whatsnew.ts

@@ -3,6 +3,10 @@
  * under "unreleased"; scripts/release.sh renames the key to the release version.
  */
 export const WHATS_NEW: Record<string, { en: string[]; de: string[] }> = {
+  "202611-00008": {
+    en: ["Instructions per chat: ⋯ → Instructions for this chat (Telegram: /prompt)"],
+    de: ["Anweisungen pro Chat: ⋯ → Anweisungen für diesen Chat (Telegram: /prompt)"],
+  },
   "202611-00007": {
     en: ["Telegram: connect your own bot under Settings → Account → Telegram and chat with CodeCraft from your phone"],
     de: ["Telegram: eigenen Bot unter Einstellungen → Konto → Telegram verbinden und von unterwegs mit CodeCraft chatten"],