Add development logging with PID tracking

- Add --dev-log flag to MCP server for file logging to /tmp/dialectic-mcp-server.log
- Include PID in all log messages for multi-instance debugging
- Improve request ID logging at debug level for IPC troubleshooting
- Update setup tool to register MCP server with RUST_LOG=dialectic_mcp_server=debug in dev mode
- Add tracing-appender dependency for non-blocking file logging

This enables detailed debugging of IPC connection lifecycle and reconnection behavior,
particularly useful for investigating reader task 'parting gift' reconnection attempts.

Author: nikomatsakis

server/Cargo.toml

@@ -41,6 +41,7 @@ thiserror = { workspace = true }
 # Logging
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
+tracing-appender = "0.2"
 
 # Command line argument parsing
 clap = { version = "4.0", features = ["derive"] }

server/src/ipc.rs

@@ -296,9 +296,10 @@ impl IPCCommunicator {
     /// for the background reader task to deliver the matching response.
     /// Uses the underlying `write_message` primitive to send the data.
     async fn send_message_with_reply(&self, message: IPCMessage) -> Result<IPCResponse> {
-        trace!(
-            "send_message_with_reply called with message ID: {}",
-            message.id
+        debug!(
+            "Sending IPC message with ID: {} (PID: {})",
+            message.id,
+            std::process::id()
         );
 
         let (tx, rx) = oneshot::channel();
@@ -566,7 +567,7 @@ impl IPCCommunicator {
     /// Processes incoming response messages from VSCode extension
     /// Matches responses to pending requests by ID and sends results back to callers
     async fn handle_response_message(inner: &Arc<Mutex<IPCCommunicatorInner>>, message_str: &str) {
-        debug!("Received IPC response: {}", message_str);
+        debug!("Received IPC response (PID: {}): {}", std::process::id(), message_str);
 
         // Parse the response message
         let response: IPCResponse = match serde_json::from_str(message_str) {
@@ -587,7 +588,7 @@ impl IPCCommunicator {
                 warn!("Failed to send response to caller - receiver dropped");
             }
         } else {
-            warn!("Received response for unknown request ID: {}", response.id);
+            warn!("Received response for unknown request ID: {} (PID: {})", response.id, std::process::id());
         }
     }
 }

server/src/main.rs

@@ -20,18 +20,47 @@ struct Args {
     /// Run PID discovery probe and exit (for testing)
     #[arg(long)]
     probe: bool,
+
+    /// Enable development logging to /tmp/dialectic-mcp-server.log
+    #[arg(long)]
+    dev_log: bool,
 }
 
 #[tokio::main]
 async fn main() -> Result<()> {
     let args = Args::parse();
+    let mut flush_guard = None;
 
     // Initialize logging to stderr (MCP uses stdout for protocol)
-    tracing_subscriber::fmt()
-        .with_env_filter(EnvFilter::from_default_env())
-        .with_writer(std::io::stderr)
-        .with_ansi(true)
-        .init();
+    // In dev mode, also log to file for debugging
+    if args.dev_log {
+        use std::fs::OpenOptions;
+        use tracing_appender::non_blocking;
+
+        let file = OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open("/tmp/dialectic-mcp-server.log")
+            .expect("Failed to open log file");
+
+        let (file_writer, _guard) = non_blocking(file);
+        flush_guard = Some(_guard);
+
+        tracing_subscriber::fmt()
+            .with_env_filter(EnvFilter::from_default_env())
+            .with_writer(file_writer)
+            .with_ansi(false) // No ANSI codes in file
+            .init();
+
+        // Also log to stderr for immediate feedback
+        eprintln!("Development logging enabled - writing to /tmp/dialectic-mcp-server.log (PID: {})", std::process::id());
+    } else {
+        tracing_subscriber::fmt()
+            .with_env_filter(EnvFilter::from_default_env())
+            .with_writer(std::io::stderr)
+            .with_ansi(true)
+            .init();
+    }
 
     if args.probe {
         info!("🔍 PROBE MODE DETECTED - Running PID discovery probe...");
@@ -56,6 +85,7 @@ async fn main() -> Result<()> {
     service.waiting().await?;
 
     info!("Dialectic MCP Server shutting down");
+    std::mem::drop(flush_guard);
     Ok(())
 }
 

setup/src/main.rs

@@ -122,13 +122,13 @@ fn main() -> Result<()> {
     if !args.skip_mcp {
         match tool {
             CLITool::QCli => {
-                success = setup_q_cli_mcp(&binary_path)?;
+                success = setup_q_cli_mcp(&binary_path, args.dev)?;
             }
             CLITool::ClaudeCode => {
                 success = setup_claude_code_mcp(&binary_path, &args.claude_scope)?;
             }
             CLITool::Both => {
-                success = setup_q_cli_mcp(&binary_path)?
+                success = setup_q_cli_mcp(&binary_path, args.dev)?
                     && setup_claude_code_mcp(&binary_path, &args.claude_scope)?;
             }
             CLITool::Auto => unreachable!("Auto should have been resolved earlier"),
@@ -385,18 +385,34 @@ fn build_and_install_extension(dev_mode: bool) -> Result<()> {
     Ok(())
 }
 
-fn setup_q_cli_mcp(binary_path: &Path) -> Result<bool> {
-    // Build the command arguments for the binary
+fn setup_q_cli_mcp(binary_path: &Path, dev_mode: bool) -> Result<bool> {
     let mut cmd = Command::new("q");
-    cmd.args([
-        "mcp", "add",
-        "--name", "dialectic",
-        "--command", &binary_path.to_string_lossy(),
-        "--force",  // Always overwrite existing configuration
-    ]);
+    
+    if dev_mode {
+        // In dev mode, register with --dev-log argument and debug logging
+        cmd.args([
+            "mcp", "add",
+            "--name", "dialectic",
+            "--command", &binary_path.to_string_lossy(),
+            "--args", "--dev-log",
+            "--env", "RUST_LOG=dialectic_mcp_server=debug",
+            "--force",  // Always overwrite existing configuration
+        ]);
+    } else {
+        // In production mode, register without arguments
+        cmd.args([
+            "mcp", "add",
+            "--name", "dialectic",
+            "--command", &binary_path.to_string_lossy(),
+            "--force",  // Always overwrite existing configuration
+        ]);
+    }
 
     println!("🔧 Registering Dialectic MCP server with Q CLI...");
     println!("   Binary path: {}", binary_path.display());
+    if dev_mode {
+        println!("   Development mode: logging to /tmp/dialectic-mcp-server.log with RUST_LOG=dialectic_mcp_server=debug");
+    }
 
     let output = cmd.output().context("Failed to execute q mcp add")?;