fix: prevent session loss and repair launch lifecycle races

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jcode"
-version = "0.70.1"
+version = "0.71.0"
 description = "Possibly the greatest coding agent ever built — blazing-fast TUI, multi-model, swarm coordination, 30+ tools"
 edition = "2024"
 autobins = false

README.md

@@ -338,6 +338,7 @@ jcode works with subscription-backed OAuth flows and many provider integrations,
 - **Alibaba Cloud Coding Plan** (`jcode login --provider alibaba-coding-plan`)
 - **Fireworks** (`jcode login --provider fireworks`)
 - **MiniMax** (`jcode login --provider minimax`)
+- **Meta Model API / Muse** (`jcode login --provider meta-muse`)
 - **LM Studio** (`jcode login --provider lmstudio`)
 - **Ollama** (`jcode login --provider ollama`)
 - **Custom OpenAI-compatible endpoint** (`jcode login --provider openai-compatible`)
@@ -363,9 +364,10 @@ There are two ways to set one up:
   jcode login --provider deepseek
   jcode login --provider opencode      # OpenCode Zen
   jcode login --provider moonshotai
+  jcode login --provider meta-muse     # Meta Model API / Muse Spark
   ```
 
-  Built-in OpenAI-compatible profile ids include: `openrouter`, `deepseek`, `zai`, `kimi`, `moonshotai`, `opencode` (OpenCode Zen), `opencode-go`, `302ai`, `baseten`, `cortecs`, `huggingface`, `nebius`, `scaleway`, `stackit`, and `firmware`. Each profile only sets the endpoint and key variable; you still pick the model with `/model` (or `--model`). Run `jcode login` with no provider to see the interactive list.
+  Built-in OpenAI-compatible profile ids include: `openrouter`, `deepseek`, `zai`, `kimi`, `moonshotai`, `meta-muse` (Meta Model API / Muse Spark), `opencode` (OpenCode Zen), `opencode-go`, `302ai`, `baseten`, `cortecs`, `huggingface`, `nebius`, `scaleway`, `stackit`, and `firmware`. Each profile only sets the endpoint and key variable; you still pick the model with `/model` (or `--model`). Run `jcode login` with no provider to see the interactive list.
 
 - **Any other endpoint** — point jcode at an arbitrary OpenAI-compatible API (hosted or local) with `jcode login --provider openai-compatible` or the scriptable `jcode provider add` command described below.
 

changelog/index.json

@@ -1,5 +1,9 @@
 {
   "entries": [
+    {
+      "version": "0.71.0",
+      "date": "2026-08-06"
+    },
     {
       "version": "0.70.1",
       "date": "2026-08-06"

changelog/v0.71.0.json

@@ -0,0 +1,20 @@
+{
+  "version": "0.71.0",
+  "date": "2026-08-06",
+  "title": "Subscription onboarding and broader model support",
+  "highlights": [
+    "Onboarding now defaults to the Jcode subscription, with clearer hosted-model pricing and a direct path to subscription details",
+    "OpenAI users can choose the full GPT-5.6 family, including Terra, and Meta Model API users can configure Muse and DeepSeek passback models"
+  ],
+  "improvements": [
+    "Todo quality feedback now distinguishes synthetic validation and tracks requirement-to-check traceability",
+    "Cargo commands report action durations to make slow build and test steps easier to identify"
+  ],
+  "fixes": [
+    "Scheduled turns no longer leak into user prompt history",
+    "Empty transcript checkpoints are prevented so session history remains usable",
+    "Terminal launches fall back cleanly when spawn hooks reject a launch",
+    "The TypeScript SDK waits for daemon registration before closing launched sessions",
+    "Permanent memory sidecar failures are distinguished from transient failures and use the current Claude model"
+  ]
+}

crates/jcode-app-core/src/agent/turn_execution.rs

@@ -20,12 +20,22 @@ impl Agent {
     }
 
     pub async fn run_once_capture(&mut self, user_message: &str) -> Result<String> {
-        self.add_message(
+        self.run_once_capture_with_display_role(user_message, None)
+            .await
+    }
+
+    pub(crate) async fn run_once_capture_with_display_role(
+        &mut self,
+        user_message: &str,
+        display_role: Option<crate::session::StoredDisplayRole>,
+    ) -> Result<String> {
+        self.add_message_with_display_role(
             Role::User,
             vec![ContentBlock::Text {
                 text: user_message.to_string(),
                 cache_control: None,
             }],
+            display_role,
         );
         self.session.save()?;
         if trace_enabled() {
@@ -41,6 +51,24 @@ impl Agent {
         images: Vec<(String, String)>,
         system_reminder: Option<String>,
         event_tx: mpsc::UnboundedSender<ServerEvent>,
+    ) -> Result<()> {
+        self.run_once_streaming_mpsc_with_display_role(
+            user_message,
+            images,
+            system_reminder,
+            event_tx,
+            None,
+        )
+        .await
+    }
+
+    pub(crate) async fn run_once_streaming_mpsc_with_display_role(
+        &mut self,
+        user_message: &str,
+        images: Vec<(String, String)>,
+        system_reminder: Option<String>,
+        event_tx: mpsc::UnboundedSender<ServerEvent>,
+        display_role: Option<crate::session::StoredDisplayRole>,
     ) -> Result<()> {
         // Inject any pending notifications before the user message
         let alerts = self.take_alerts();
@@ -62,7 +90,7 @@ impl Agent {
         self.current_turn_system_reminder =
             system_reminder.filter(|value| !value.trim().is_empty());
 
-        self.append_user_context_message(user_message, images)?;
+        self.append_user_context_message_with_display_role(user_message, images, display_role)?;
         crate::telemetry::record_turn();
         let turn_started_at = Instant::now();
         let start_message_index = self.message_count();
@@ -78,6 +106,15 @@ impl Agent {
         &mut self,
         user_message: &str,
         images: Vec<(String, String)>,
+    ) -> Result<()> {
+        self.append_user_context_message_with_display_role(user_message, images, None)
+    }
+
+    fn append_user_context_message_with_display_role(
+        &mut self,
+        user_message: &str,
+        images: Vec<(String, String)>,
+        display_role: Option<crate::session::StoredDisplayRole>,
     ) -> Result<()> {
         let mut blocks: Vec<ContentBlock> = images
             .into_iter()
@@ -95,7 +132,7 @@ impl Agent {
             ));
         }
 
-        self.add_message(Role::User, blocks);
+        self.add_message_with_display_role(Role::User, blocks, display_role);
         self.session.save()
     }
 

crates/jcode-app-core/src/ambient/runner.rs

@@ -396,7 +396,12 @@ impl AmbientRunnerHandle {
         agent.restore_session(session_id)?;
 
         let reminder = ambient::format_scheduled_session_message(item);
-        let _ = agent.run_once_capture(&reminder).await?;
+        let _ = agent
+            .run_once_capture_with_display_role(
+                &reminder,
+                Some(crate::session::StoredDisplayRole::System),
+            )
+            .await?;
         agent.mark_closed();
         Ok(())
     }
@@ -470,7 +475,12 @@ impl AmbientRunnerHandle {
         }
 
         let reminder = ambient::format_scheduled_session_message(item);
-        let _ = agent.run_once_capture(&reminder).await?;
+        let _ = agent
+            .run_once_capture_with_display_role(
+                &reminder,
+                Some(crate::session::StoredDisplayRole::System),
+            )
+            .await?;
         agent.mark_closed();
         Ok(child_session_id)
     }

crates/jcode-app-core/src/notifications.rs

@@ -452,7 +452,7 @@ pub fn send_macos_turn_notification(
     #[cfg(not(target_os = "macos"))]
     {
         let _ = (title, subtitle, body, sound);
-        return false;
+        false
     }
 
     #[cfg(target_os = "macos")]

crates/jcode-app-core/src/server/client_actions.rs

@@ -105,10 +105,9 @@ pub(super) async fn handle_notify_session(
     };
 
     let ran_immediately = if target_has_client {
-        super::live_turn::run_live_turn_if_idle(
+        super::live_turn::run_live_system_turn_if_idle(
             &session_id,
             &message,
-            None,
             ctx.sessions,
             super::live_turn::LiveTurnSwarmContext::new(
                 ctx.swarm_members,
@@ -992,6 +991,7 @@ pub(super) async fn handle_resume_all_sessions(
             Arc::clone(&agent),
             String::new(),
             Some(reminder),
+            None,
             Some("resuming interrupted session".to_string()),
             super::live_turn::LiveTurnSwarmContext::new(
                 swarm_members,

crates/jcode-app-core/src/server/client_actions_tests.rs

@@ -461,6 +461,7 @@ async fn notify_session_runs_scheduled_task_immediately_for_idle_live_session()
     let guard = agent.lock().await;
     assert!(guard.messages().iter().any(|message| {
         message.role == Role::User
+            && message.display_role == Some(crate::session::StoredDisplayRole::System)
             && message
                 .content_preview()
                 .contains("[Scheduled task] Task: Follow up")

crates/jcode-app-core/src/server/client_lifecycle.rs

@@ -2834,6 +2834,7 @@ async fn append_context_message(
     let _ = client_event_tx.send(event);
 }
 
+#[allow(clippy::too_many_arguments)]
 async fn start_processing_message(
     message: ProcessingMessage,
     client_session_id: &str,

crates/jcode-app-core/src/server/live_turn.rs

@@ -95,6 +95,7 @@ pub(super) async fn spawn_tracked_live_turn(
     agent: Arc<Mutex<Agent>>,
     message: String,
     system_reminder: Option<String>,
+    display_role: Option<crate::session::StoredDisplayRole>,
     status_detail: Option<String>,
     swarm: LiveTurnSwarmContext,
 ) {
@@ -117,14 +118,27 @@ pub(super) async fn spawn_tracked_live_turn(
             let agent_guard = agent.lock().await;
             agent_guard.message_count()
         };
-        let result = process_message_streaming_mpsc(
-            Arc::clone(&agent),
-            &message,
-            vec![],
-            system_reminder,
-            event_tx.clone(),
-        )
-        .await;
+        let result = if let Some(display_role) = display_role {
+            let mut agent = agent.lock().await;
+            agent
+                .run_once_streaming_mpsc_with_display_role(
+                    &message,
+                    vec![],
+                    system_reminder,
+                    event_tx.clone(),
+                    Some(display_role),
+                )
+                .await
+        } else {
+            process_message_streaming_mpsc(
+                Arc::clone(&agent),
+                &message,
+                vec![],
+                system_reminder,
+                event_tx.clone(),
+            )
+            .await
+        };
         match result {
             Ok(()) => {
                 let completion_report = {
@@ -189,6 +203,30 @@ pub(super) async fn run_live_turn_if_idle(
         agent,
         message.to_string(),
         system_reminder,
+        None,
+        detail,
+        swarm,
+    )
+    .await;
+    true
+}
+
+pub(super) async fn run_live_system_turn_if_idle(
+    session_id: &str,
+    message: &str,
+    sessions: &SessionAgents,
+    swarm: LiveTurnSwarmContext,
+) -> bool {
+    let Some(agent) = idle_live_agent(session_id, sessions, &swarm.members).await else {
+        return false;
+    };
+    let detail = Some(truncate_detail(message, 120)).filter(|detail| !detail.is_empty());
+    spawn_tracked_live_turn(
+        session_id,
+        agent,
+        message.to_string(),
+        None,
+        Some(crate::session::StoredDisplayRole::System),
         detail,
         swarm,
     )

crates/jcode-app-core/src/tool/bash.rs

@@ -34,6 +34,38 @@ const BASH_TOOL_DESCRIPTION: &str = "Run a bash command.";
 const WINDOWS_SHELL_TOOL_DESCRIPTION: &str =
     "Run a Windows cmd.exe command (compatibility name `bash`). Use cmd.exe syntax, not Bash.";
 
+#[cfg(unix)]
+fn shell_single_quote(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "'\"'\"'"))
+}
+
+/// Route ordinary `cargo` invocations (including those inside child scripts)
+/// through the repository wrapper. Besides applying the project's build policy,
+/// that wrapper appends real action timings to rust-actions.jsonl.
+#[cfg(unix)]
+fn wrap_repo_cargo_commands(command: &str, working_dir: Option<&Path>) -> Option<String> {
+    let working_dir = working_dir?;
+    let repo = crate::build::find_repo_in_ancestors(working_dir)?;
+    let wrapper = repo.join("scripts").join("dev_cargo.sh");
+    if !wrapper.is_file() {
+        return None;
+    }
+
+    Some(format!(
+        r#"export JCODE_DEV_CARGO_SCRIPT={wrapper}
+cargo() {{
+  if [[ "${{JCODE_IN_DEV_CARGO:-0}}" == "1" ]]; then
+    command cargo "$@"
+  else
+    JCODE_IN_DEV_CARGO=1 "$JCODE_DEV_CARGO_SCRIPT" "$@"
+  fi
+}}
+export -f cargo
+{command}"#,
+        wrapper = shell_single_quote(&wrapper.to_string_lossy()),
+    ))
+}
+
 /// Build a clear timeout message. The `timeout` param is in milliseconds, which
 /// agents frequently mistake for seconds (e.g. passing 1000 thinking it means
 /// 1000s when it is 1s). Spell out the seconds equivalent and, for suspiciously
@@ -700,6 +732,12 @@ impl Tool for BashTool {
             return Err(anyhow::anyhow!(refusal));
         }
 
+        #[cfg(unix)]
+        if let Some(wrapped) = wrap_repo_cargo_commands(&params.command, ctx.working_dir.as_deref())
+        {
+            params.command = wrapped;
+        }
+
         if run_in_background {
             return self.execute_background(params, ctx).await;
         }

crates/jcode-app-core/src/tool/bash_tests.rs

@@ -5,6 +5,31 @@ use crate::tool::bash::{BashTool, parse_heuristic_progress};
 use serde_json::json;
 use tokio::sync::mpsc;
 
+#[test]
+fn repository_commands_export_a_logged_cargo_function() {
+    let repo =
+        crate::build::find_repo_in_ancestors(std::path::Path::new(env!("CARGO_MANIFEST_DIR")))
+            .expect("test runs inside the jcode repository");
+    let wrapped = wrap_repo_cargo_commands("cargo test -p demo && echo done", Some(&repo))
+        .expect("jcode repository has dev_cargo.sh");
+
+    assert!(wrapped.contains("export JCODE_DEV_CARGO_SCRIPT="));
+    assert!(wrapped.contains("JCODE_IN_DEV_CARGO=1 \"$JCODE_DEV_CARGO_SCRIPT\" \"$@\""));
+    assert!(wrapped.contains("export -f cargo"));
+    assert!(wrapped.ends_with("cargo test -p demo && echo done"));
+}
+
+#[test]
+fn cargo_routing_is_limited_to_the_jcode_repository() {
+    assert!(wrap_repo_cargo_commands("cargo test", Some(std::path::Path::new("/"))).is_none());
+    assert!(wrap_repo_cargo_commands("cargo test", None).is_none());
+}
+
+#[test]
+fn cargo_wrapper_path_is_shell_quoted() {
+    assert_eq!(shell_single_quote("a'b"), "'a'\"'\"'b'");
+}
+
 fn make_ctx(stdin_tx: Option<mpsc::UnboundedSender<StdinInputRequest>>) -> ToolContext {
     ToolContext {
         session_id: "test-session".to_string(),