refactor: remove session persistence from opencode calls

Remove session ID handling to prevent context rot in long-running autonomous
loops. Each opencode CLI invocation now starts with a fresh context, relying
on prompts and the plan file for continuity between tasks.

Changes:
- Remove session_id field from Executor struct
- Remove resetSession() method and all calls to it
- Remove continue_session parameter from runOpencode/runWithRetry
- Remove --session argument construction
- Remove test for session ID continuation
- Simplify deinit() method (no cleanup needed)

This ensures opencoder can run indefinitely without accumulating stale
context that could degrade AI performance over many cycles.

Signed-off-by: leocavalcante <[email protected]>

Author: leocavalcante

src/executor.zig

@@ -21,17 +21,17 @@ pub const Executor = struct {
     cfg: *const config.Config,
     log: *Logger,
     allocator: Allocator,
-    session_id: ?[]const u8,
     opencode_cmd: []const u8,
+    current_child_pid: ?std.posix.pid_t,
 
     /// Initialize executor
     pub fn init(cfg: *const config.Config, log: *Logger, allocator: Allocator) Executor {
         return Executor{
             .cfg = cfg,
             .log = log,
             .allocator = allocator,
-            .session_id = null,
             .opencode_cmd = "opencode",
+            .current_child_pid = null,
         };
     }
 
@@ -41,16 +41,14 @@ pub const Executor = struct {
             .cfg = cfg,
             .log = log,
             .allocator = allocator,
-            .session_id = null,
             .opencode_cmd = opencode_cmd,
+            .current_child_pid = null,
         };
     }
 
     /// Cleanup executor resources
     pub fn deinit(self: *Executor) void {
-        if (self.session_id) |sid| {
-            self.allocator.free(sid);
-        }
+        _ = self;
     }
 
     /// Run planning phase
@@ -63,14 +61,7 @@ pub const Executor = struct {
         var title_buf: [64]u8 = undefined;
         const title = std.fmt.bufPrint(&title_buf, "Opencoder Planning Cycle {d}", .{cycle}) catch "Opencoder Planning";
 
-        const result = try self.runWithRetry(self.cfg.planning_model, title, prompt, false);
-
-        if (result == .success) {
-            // Reset session for new cycle
-            self.resetSession();
-        }
-
-        return result;
+        return try self.runWithRetry(self.cfg.planning_model, title, prompt);
     }
 
     /// Run task execution
@@ -83,15 +74,7 @@ pub const Executor = struct {
         var title_buf: [64]u8 = undefined;
         const title = std.fmt.bufPrint(&title_buf, "Opencoder Execution Cycle {d}", .{cycle}) catch "Opencoder Execution";
 
-        const continue_session = self.session_id != null;
-        const result = try self.runWithRetry(self.cfg.execution_model, title, prompt, continue_session);
-
-        if (result == .success and self.session_id == null) {
-            // Set session ID after first successful task (allocate owned memory)
-            self.session_id = try std.fmt.allocPrint(self.allocator, "ses_{d}", .{cycle});
-        }
-
-        return result;
+        return try self.runWithRetry(self.cfg.execution_model, title, prompt);
     }
 
     /// Run evaluation phase
@@ -110,7 +93,7 @@ pub const Executor = struct {
                 self.log.statusFmt("[Cycle {d}] Evaluation retry {d}/{d}", .{ cycle, attempt + 1, self.cfg.max_retries });
             }
 
-            const result = self.runOpencode(self.cfg.planning_model, title, prompt, false);
+            const result = self.runOpencode(self.cfg.planning_model, title, prompt);
             if (result) |output| {
                 // Check for COMPLETE or NEEDS_WORK in output
                 if (std.mem.indexOf(u8, output, "COMPLETE") != null) {
@@ -150,24 +133,27 @@ pub const Executor = struct {
         return "NEEDS_WORK";
     }
 
-    /// Reset session for new cycle
-    pub fn resetSession(self: *Executor) void {
-        if (self.session_id) |sid| {
-            self.allocator.free(sid);
+    /// Kill current child process if running
+    pub fn killCurrentChild(self: *Executor) void {
+        if (self.current_child_pid) |pid| {
+            self.log.logFmt("Terminating child process (PID: {d})", .{pid});
+            std.posix.kill(pid, std.posix.SIG.TERM) catch |err| {
+                self.log.logErrorFmt("Failed to kill child process: {s}", .{@errorName(err)});
+            };
+            self.current_child_pid = null;
         }
-        self.session_id = null;
     }
 
     // Internal helper to run with retry logic
-    fn runWithRetry(self: *Executor, model: []const u8, title: []const u8, prompt: []const u8, continue_session: bool) !ExecutionResult {
+    fn runWithRetry(self: *Executor, model: []const u8, title: []const u8, prompt: []const u8) !ExecutionResult {
         var attempt: u32 = 0;
 
         while (attempt < self.cfg.max_retries) : (attempt += 1) {
             if (attempt > 0) {
                 self.log.logFmt("Retry attempt {d}/{d}", .{ attempt + 1, self.cfg.max_retries });
             }
 
-            const result = self.runOpencode(model, title, prompt, continue_session);
+            const result = self.runOpencode(model, title, prompt);
             if (result) |output| {
                 self.allocator.free(output);
                 return .success;
@@ -201,7 +187,7 @@ pub const Executor = struct {
     }
 
     // Run opencode CLI and return output
-    fn runOpencode(self: *Executor, model: []const u8, title: []const u8, prompt: []const u8, continue_session: bool) ![]u8 {
+    fn runOpencode(self: *Executor, model: []const u8, title: []const u8, prompt: []const u8) ![]u8 {
         var args = std.ArrayListUnmanaged([]const u8){};
         defer args.deinit(self.allocator);
 
@@ -211,14 +197,6 @@ pub const Executor = struct {
         try args.append(self.allocator, model);
         try args.append(self.allocator, "--title");
         try args.append(self.allocator, title);
-
-        if (continue_session) {
-            if (self.session_id) |sid| {
-                try args.append(self.allocator, "--session");
-                try args.append(self.allocator, sid);
-            }
-        }
-
         try args.append(self.allocator, prompt);
 
         self.log.logVerbose("Running opencode...");
@@ -232,6 +210,10 @@ pub const Executor = struct {
 
         try child.spawn();
 
+        // Store PID for potential termination
+        self.current_child_pid = child.id;
+        defer self.current_child_pid = null;
+
         // Read stdout
         var stdout_list = std.ArrayListUnmanaged(u8){};
 
@@ -354,7 +336,6 @@ test "Executor.init creates executor" {
 
     const executor = Executor.init(&test_cfg, test_logger, allocator);
     try std.testing.expectEqualStrings("opencode", executor.opencode_cmd);
-    try std.testing.expect(executor.session_id == null);
 }
 
 test "Executor.initWithCmd creates executor with custom command" {
@@ -413,7 +394,7 @@ test "runOpencode handles successful execution" {
     var executor = Executor.initWithCmd(&test_cfg, test_logger, allocator, mock_path);
     defer executor.deinit();
 
-    const result = try executor.runOpencode("test/model", "Test", "test prompt", false);
+    const result = try executor.runOpencode("test/model", "Test", "test prompt");
     defer allocator.free(result);
 
     try std.testing.expect(result.len > 0);
@@ -448,43 +429,6 @@ test "runOpencode handles process failure" {
     var executor = Executor.initWithCmd(&test_cfg, test_logger, allocator, mock_path);
     defer executor.deinit();
 
-    const result = executor.runOpencode("test/model", "Test", "test prompt", false);
+    const result = executor.runOpencode("test/model", "Test", "test prompt");
     try std.testing.expectError(error.OpencodeFailed, result);
 }
-
-test "runOpencode passes session ID when continuing" {
-    const allocator = std.testing.allocator;
-    const test_logger = try createTestLogger(allocator);
-    defer destroyTestLogger(test_logger, allocator);
-
-    const test_cfg = config.Config{
-        .planning_model = "test/model",
-        .execution_model = "test/model",
-        .project_dir = "/tmp",
-        .verbose = false,
-        .user_hint = null,
-        .max_retries = 3,
-        .backoff_base = 1,
-        .log_retention = 30,
-        .max_file_size = 1024 * 1024,
-        .log_buffer_size = 2048,
-        .task_pause_seconds = 2,
-    };
-
-    // Get absolute path to mock script
-    var cwd_buf: [std.fs.max_path_bytes]u8 = undefined;
-    const cwd = try std.fs.cwd().realpath(".", &cwd_buf);
-    const mock_path = try std.fs.path.join(allocator, &.{ cwd, "test_helpers/mock_opencode_success.sh" });
-    defer allocator.free(mock_path);
-
-    var executor = Executor.initWithCmd(&test_cfg, test_logger, allocator, mock_path);
-    defer executor.deinit();
-
-    // Set a session ID
-    executor.session_id = try std.fmt.allocPrint(allocator, "test_session_123", .{});
-
-    const result = try executor.runOpencode("test/model", "Test", "test prompt", true);
-    defer allocator.free(result);
-
-    try std.testing.expect(result.len > 0);
-}

src/loop.zig

@@ -18,6 +18,8 @@ const ExecutionResult = @import("executor.zig").ExecutionResult;
 
 /// Shutdown flag for signal handling
 var shutdown_requested: bool = false;
+/// Signal counter for force kill (2 Ctrl+C = force exit)
+var signal_count: u8 = 0;
 
 /// Main execution loop
 pub const Loop = struct {
@@ -59,14 +61,17 @@ pub const Loop = struct {
             self.log.sayFmt("Hint: {s}", .{hint});
         }
 
-        self.log.say("Running continuously (Ctrl+C to stop)");
+        self.log.say("Running continuously (Ctrl+C to stop, Ctrl+C twice to force)");
         self.log.say("");
 
         while (!shutdown_requested) {
             self.log.say("");
             self.log.sayFmt("[Cycle {d}]", .{self.st.cycle});
             self.log.setCycle(self.st.cycle);
 
+            // Check shutdown before starting any work
+            if (shutdown_requested) break;
+
             // Planning phase
             if (!fsutil.fileExists(self.paths.current_plan) or self.st.phase == .planning) {
                 const result = self.executor.runPlanning(self.st.cycle) catch |err| {
@@ -133,6 +138,9 @@ pub const Loop = struct {
                 try self.st.save(self.paths.state_file, self.allocator);
             }
 
+            // Check shutdown before execution phase
+            if (shutdown_requested) break;
+
             // Execution phase
             self.log.logFmt("[Cycle {d}] Executing tasks...", .{self.st.cycle});
 
@@ -213,6 +221,9 @@ pub const Loop = struct {
                 std.Thread.sleep(self.cfg.task_pause_seconds * std.time.ns_per_s);
             }
 
+            // Check shutdown before evaluation
+            if (shutdown_requested) break;
+
             // Evaluation phase
             const eval_result = evaluator.evaluate(
                 self.executor,
@@ -253,7 +264,6 @@ pub const Loop = struct {
                 self.st.task_index = 0;
                 self.st.current_task_num = 0;
                 self.st.total_tasks = 0;
-                self.executor.resetSession();
             } else {
                 // Check if there are actually pending tasks
                 if (!evaluator.hasPendingTasks(self.paths.current_plan, self.allocator, self.cfg.max_file_size)) {
@@ -272,7 +282,6 @@ pub const Loop = struct {
                     self.st.task_index = 0;
                     self.st.current_task_num = 0;
                     self.st.total_tasks = 0;
-                    self.executor.resetSession();
                 } else {
                     self.log.sayFmt("[Cycle {d}] Needs more work, continuing", .{self.st.cycle});
                     self.st.phase = .execution;
@@ -283,6 +292,13 @@ pub const Loop = struct {
             self.log.sayFmt("[Cycle {d}] Complete", .{self.st.cycle -| 1});
         }
 
+        // Kill any running child process on shutdown
+        if (shutdown_requested) {
+            self.log.say("");
+            self.log.say("Shutdown requested, cleaning up...");
+            self.executor.killCurrentChild();
+        }
+
         self.log.say("");
         self.log.say("Loop stopped");
     }
@@ -307,7 +323,15 @@ pub fn setupSignalHandlers() void {
 
 fn handleSignal(sig: i32) callconv(std.builtin.CallingConvention.c) void {
     _ = sig;
+    signal_count += 1;
     shutdown_requested = true;
+
+    // On second signal, force exit immediately
+    if (signal_count >= 2) {
+        const stderr_file = std.fs.File{ .handle = posix.STDERR_FILENO };
+        _ = stderr_file.write("\n\nForce killing...\n") catch {};
+        posix.exit(130); // 128 + SIGINT(2) = 130
+    }
 }
 
 /// Request shutdown (for programmatic use)
@@ -456,7 +480,7 @@ test "Loop.init creates loop with correct fields" {
 test "backoffSleep calculates correct sleep time" {
     const allocator = std.testing.allocator;
 
-    // Create test dependencies with backoff_base = 10
+    // Create test dependencies with backoff_base = 1 for fast tests
     const test_logger = try createTestLogger(allocator);
     defer destroyTestLogger(test_logger, allocator);
 
@@ -470,7 +494,7 @@ test "backoffSleep calculates correct sleep time" {
         .verbose = false,
         .user_hint = null,
         .max_retries = 3,
-        .backoff_base = 10,
+        .backoff_base = 1,
         .log_retention = 30,
         .max_file_size = 1024 * 1024,
         .log_buffer_size = 2048,
@@ -492,19 +516,16 @@ test "backoffSleep calculates correct sleep time" {
         allocator,
     );
 
-    // Note: We can't easily test the actual sleep without waiting,
-    // but we can verify the calculation: backoff_base * 2 = 10 * 2 = 20 seconds
-    // The backoffSleep function uses: self.cfg.backoff_base * 2
-    try std.testing.expectEqual(@as(u32, 10), loop.cfg.backoff_base);
+    // The backoffSleep function uses: self.cfg.backoff_base * 2 = 1 * 2 = 2 seconds
+    try std.testing.expectEqual(@as(u32, 1), loop.cfg.backoff_base);
 
-    // Call backoffSleep - it should sleep for 20 seconds, but we can't verify timing in tests
-    // Just ensure it doesn't crash
+    // Call backoffSleep - it should sleep for 2 seconds
     const start = std.time.nanoTimestamp();
     loop.backoffSleep();
     const elapsed = std.time.nanoTimestamp() - start;
 
-    // Verify it actually slept (at least 19 seconds to account for scheduling)
-    try std.testing.expect(elapsed >= 19 * std.time.ns_per_s);
+    // Verify it actually slept (at least 1.9 seconds to account for scheduling)
+    try std.testing.expect(elapsed >= (19 * std.time.ns_per_s) / 10);
 }
 
 test "Loop state transitions between phases" {