feat: add scene-based recording, e2e tests, and improved TUI state indicators

client/src/tui.c

@@ -15,6 +15,7 @@
 #include "plugins.h"
 #include "script.h"
 #include <CarlaHost.h>
+#include "log.h"
 
 /* ---------- engine alive indicator ---------- */
 static bool engine_running = false;
@@ -40,7 +41,15 @@ int send_command(const char *cmd) {
 /* ---------- Stub functions (no engine) ---------- */
 // Clip states – dummy values used as placeholders
 typedef enum { CLIP_EMPTY, CLIP_RECORDING, CLIP_LOOPING, CLIP_STOPPED } ClipState;
-static const char *clip_state_string(ClipState s) { (void)s; return "?"; }
+static const char *clip_state_string(ClipState s) {
+    switch (s) {
+        case CLIP_EMPTY:      return " ";
+        case CLIP_RECORDING:  return "R";
+        case CLIP_LOOPING:    return "L";
+        case CLIP_STOPPED:    return "P";
+        default:              return "?";
+    }
+}
 
 /* Grid dimensions */
 #define GRID_ROWS 8
@@ -131,6 +140,17 @@ static void draw_cell(int grid, int row, int col, bool selected) {
             mvaddch(y+dy, x+dx, ' ');
     mvprintw(y+1, x+1, "%2d", grid*GRID_ROWS*GRID_COLS + row*GRID_COLS + col);
     attroff(COLOR_PAIR(color));
+
+    /* Draw state indicator character below the number, centered */
+    const char state_char = (s == STATE_RECORD)  ? 'R' :
+                            (s == STATE_LOOPING) ? 'L' :
+                            (s == STATE_PAUSED)  ? 'P' : '.';
+    int state_color = (s == STATE_RECORD)  ? COLOR_RECORDING :
+                      (s == STATE_LOOPING) ? COLOR_LOOPING :
+                      (s == STATE_PAUSED)  ? COLOR_STOPPED : COLOR_EMPTY;
+    attron(COLOR_PAIR(state_color));
+    mvaddch(y+2, x + CELL_WIDTH / 2, state_char);
+    attroff(COLOR_PAIR(state_color));
 }
 
 static void draw_rack(void) {
@@ -187,6 +207,7 @@ static void draw_grid(void) {
 
 /* ---------- TUI init ---------- */
 void tui_init(void) {
+    log_init();
     initscr();
     cbreak(); noecho(); keypad(stdscr, TRUE); curs_set(0);
     debug_mode = (getenv("LOOPER_DEBUG") != NULL);
@@ -231,8 +252,15 @@ void tui_run(void) {
                     int ch, sc;
                     ChannelState st;
                     if (parse_status_line(line, &ch, &sc, &st)) {
-                        if (ch >= 0 && ch < GRID_ROWS * GRID_COLS)
+                        int idx = sc * GRID_COLS + ch;
-                            cell_state[ch] = st;
+                        if (idx >= 0 && idx < GRID_ROWS * GRID_COLS) {
+                            log_msg("DIAG status: line=\"%s\" ch=%d sc=%d st=%d idx=%d", line, ch, sc, (int)st, idx);
+                            cell_state[idx] = st;
+                        } else {
+                            log_msg("DIAG status out of range: line=\"%s\" ch=%d sc=%d idx=%d", line, ch, sc, idx);
+                        }
+                    } else {
+                        log_msg("DIAG status parse failed: \"%s\"", line);
                     }
                     if (nl) {
                         *nl = '\n';
@@ -268,6 +296,9 @@ void tui_run(void) {
             close(nfd);
         }
 
+        /* Immediately redraw the grid so status changes appear without waiting for next keypress */
+        draw_grid();
+
         if (in_colon) {
             int chc = getch();
             if (chc == '\n') {
@@ -326,8 +357,14 @@ void tui_run(void) {
         case 'l': case KEY_RIGHT:  selected_col = (selected_col+1)%GRID_COLS; break;
         case 't': {
             char cmd[32];
+            log_msg("DIAG t pressed: selected_row=%d selected_col=%d", selected_row, selected_col);
+            // channel = col, scene = row
+            snprintf(cmd, sizeof(cmd), "set_scene %d %d\n", selected_col, selected_row);
+            send_command(cmd);
+            log_msg("DIAG sent: %s", cmd);
             snprintf(cmd, sizeof(cmd), "record %d\n", selected_col);
             send_command(cmd);
+            log_msg("DIAG sent: %s", cmd);
             break;
         }
         case 's':
@@ -350,6 +387,9 @@ void tui_run(void) {
             break;
         case 'b': {
             char cmd[16];
+            // channel = col, scene = row
+            snprintf(cmd, sizeof(cmd), "set_scene %d %d\n", selected_col, selected_row);
+            send_command(cmd);
             snprintf(cmd, sizeof(cmd), "bind %d\n", selected_col);
             send_command(cmd);
             break;

e2e/gen_tone.c

@@ -0,0 +1,78 @@
+#include <jack/jack.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+static jack_port_t *output_port;
+static jack_client_t *client;
+static volatile int running = 1;
+static double phase = 0.0;
+static double freq = 440.0;
+static int sample_rate = 48000;
+static int total_samples = 0;
+static int samples_written = 0;
+
+int process(jack_nframes_t nframes, void *arg) {
+    jack_default_audio_sample_t *out =
+        (jack_default_audio_sample_t *)jack_port_get_buffer(output_port, nframes);
+    if (!out) return 0;
+    for (jack_nframes_t i = 0; i < nframes; i++) {
+        out[i] = sin(2 * M_PI * phase);
+        phase += freq / sample_rate;
+        if (phase >= 1.0) phase -= 1.0;
+        samples_written++;
+        if (total_samples > 0 && samples_written >= total_samples) {
+            running = 0;
+            break;
+        }
+    }
+    return 0;
+}
+
+void shutdown(void *arg) { running = 0; }
+
+int main(int argc, char **argv) {
+    if (argc < 3) {
+        fprintf(stderr, "Usage: gen_tone <duration_seconds> <target_port> [frequency]\n");
+        return 1;
+    }
+    double duration = atof(argv[1]);
+    const char *target = argv[2];
+    if (argc >= 4) freq = atof(argv[3]);
+
+    jack_status_t status;
+    client = jack_client_open("gen_tone", JackNoStartServer, &status);
+    if (!client) { fprintf(stderr, "Cannot open JACK client\n"); return 1; }
+
+    sample_rate = jack_get_sample_rate(client);
+    total_samples = (int)(duration * sample_rate + 0.5);
+
+    output_port = jack_port_register(client, "output",
+                                     JACK_DEFAULT_AUDIO_TYPE,
+                                     JackPortIsOutput, 0);
+    if (!output_port) { fprintf(stderr, "Cannot register port\n"); return 1; }
+
+    jack_set_process_callback(client, process, NULL);
+    jack_on_shutdown(client, shutdown, NULL);
+    if (jack_activate(client)) { fprintf(stderr, "Cannot activate client\n"); return 1; }
+
+    // Connect to target
+    const char **ports = jack_get_ports(client, target,
+                                        JACK_DEFAULT_AUDIO_TYPE,
+                                        JackPortIsInput);
+    if (!ports || !ports[0]) {
+        fprintf(stderr, "Target port '%s' not found\n", target);
+        return 1;
+    }
+    if (jack_connect(client, jack_port_name(output_port), ports[0])) {
+        fprintf(stderr, "Cannot connect port\n");
+        return 1;
+    }
+
+    while (running) sleep(1);
+
+    jack_client_close(client);
+    return 0;
+}

e2e/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "looper-e2e",
+  "private": true,
+  "scripts": {
+    "test": "tsx test.ts",
+    "compile": "tsc"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "tsx": "^4.0.0",
+    "@types/node": "^20.0.0"
+  }
+}

e2e/test.ts

@@ -0,0 +1,746 @@
+import { execSync, exec, ChildProcess } from "child_process";
+import * as path from "path";
+import * as fs from "fs";
+
+const PROJECT_DIR = path.resolve(__dirname, "..");
+const ENGINE_BIN = path.join(PROJECT_DIR, "engine/looper");
+const CLIENT_BIN = path.join(PROJECT_DIR, "client/looper-client");
+const STATUS_FIFO = "/tmp/looper_status";
+const CMD_FIFO = "/tmp/looper_cmd";
+
+let cmdFifoFd: number | null = null;
+
+function run(cmd: string, timeout_sec = 15): string {
+  return execSync(cmd, { encoding: "utf-8", timeout: timeout_sec * 1000 }).trim();
+}
+
+function runNoThrow(cmd: string): void {
+  try { run(cmd); } catch { /* ignore */ }
+}
+
+function tmuxSendKeys(session: string, pane: string, keys: string) {
+  run(`tmux send-keys -t ${session}:${pane} ${JSON.stringify(keys)}`);
+}
+
+function tmuxCapturePane(session: string, pane: string): string {
+  return run(`tmux capture-pane -t ${session}:${pane} -p`);
+}
+
+function wait(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/** Wait for a file to exist, up to `timeoutMs` milliseconds. */
+function waitForFile(filepath: string, timeoutMs: number): Promise<void> {
+  const start = Date.now();
+  return new Promise<void>((resolve, reject) => {
+    const check = () => {
+      if (fs.existsSync(filepath)) {
+        resolve();
+      } else if (Date.now() - start > timeoutMs) {
+        reject(new Error(`Timeout waiting for ${filepath}`));
+      } else {
+        setTimeout(check, 200);
+      }
+    };
+    check();
+  });
+}
+
+function waitForCommandFifo(timeoutMs = 5000): Promise<void> {
+  return waitForFile(CMD_FIFO, timeoutMs);
+}
+
+function openCmdFifo(): void {
+  // Wait for FIFO to exist (engine creates it)
+  let waited = 0;
+  while (!fs.existsSync(CMD_FIFO) && waited < 5000) {
+    const waitUntil = Date.now() + 200;
+    require("child_process").execSync(`sleep 0.2`);
+    waited += 200;
+  }
+  cmdFifoFd = fs.openSync(CMD_FIFO, 'w');
+}
+
+function writeFifoCommand(cmd: string): void {
+  if (cmdFifoFd === null) {
+    openCmdFifo();
+  }
+  fs.writeSync(cmdFifoFd, cmd + '\n');
+}
+
+function setupTest() {
+  process.stdout.write("  Killing stale processes...\n");
+  runNoThrow("pkill -9 -x looper");
+  runNoThrow("pkill -9 -x looper-client");
+  runNoThrow("pkill -9 -x jack_capture");
+  runNoThrow("tmux kill-session -t looper 2>/dev/null || true");
+  process.stdout.write("  Checking JACK...\n");
+  try {
+    run("jack_wait -c -t 5", 10);
+  } catch {
+    console.warn("  JACK server is not running. Tests may fail.");
+  }
+  process.stdout.write("  Removing old temp files...\n");
+  run("rm -f /tmp/looper_cmd /tmp/looper_status /tmp/test.wav /tmp/captured.wav /tmp/loop.wav /tmp/save.wav /tmp/load_test.wav /tmp/loaded.wav save_ch*.wav save.wav loop.wav");
+}
+
+function teardownTest() {
+  if (cmdFifoFd !== null) {
+    fs.closeSync(cmdFifoFd);
+    cmdFifoFd = null;
+  }
+  runNoThrow("pkill -9 -x looper");
+  runNoThrow("pkill -9 -x looper-client");
+  runNoThrow("pkill -9 -x jack_capture");
+  runNoThrow("tmux kill-session -t looper");
+}
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function startEngine(): Promise<ChildProcess> {
+  process.stdout.write("  Starting engine directly...\n");
+  const stderrFile = "/tmp/engine_stderr.log";
+  const proc = exec(`${ENGINE_BIN} 2>${stderrFile}`, { cwd: PROJECT_DIR });
+
+  // Wait for the status FIFO to appear (up to 10 seconds)
+  try {
+    await Promise.race([
+      waitForFile(STATUS_FIFO, 10000),
+      wait(11000),
+    ]);
+  } catch {
+    process.stdout.write("  Engine status FIFO did not appear within timeout\n");
+    if (proc.pid && !isProcessAlive(proc.pid)) {
+      process.stdout.write("  Engine process died prematurely. stderr log:\n");
+      const stderr = execSync(`cat ${stderrFile}`, { encoding: "utf-8" }).trim();
+      process.stdout.write(stderr + "\n");
+    }
+  }
+
+  if (proc.pid && isProcessAlive(proc.pid)) {
+    process.stdout.write("  Engine started (pid " + proc.pid + ")\n");
+  } else {
+    process.stdout.write("  Engine process is not alive after start attempt\n");
+  }
+  return proc;
+}
+
+async function startClientInTmux(): Promise<void> {
+  // Kill any stale session (silently)
+  runNoThrow("tmux kill-session -t looper 2>/dev/null");
+  run("tmux new-session -d -s looper");
+  // Resize the window (width x height) so we can see the full grid and status line
+  run("tmux resize-window -t looper:0 -x 120 -y 50 2>/dev/null || true");
+  // Launch the client
+  run(`tmux send-keys -t looper:0 ${JSON.stringify(CLIENT_BIN)} Enter`);
+  // Wait for the client to draw the initial frame (max 10 seconds, poll every 500 ms)
+  const deadline = Date.now() + 10000;
+  let pane = "";
+  while (Date.now() < deadline) {
+    await wait(500);
+    pane = tmuxCapturePane("looper", "0");
+    if (pane.includes("[online]") || pane.includes("Selected:")) {
+      break;
+    }
+  }
+  // Final short extra wait to ensure status lines are updated
+  await wait(500);
+}
+
+/* Check if the tmux pane contains a given substring */
+function tmuxContains(text: string): boolean {
+  const pane = tmuxCapturePane("looper", "0");
+  return pane.includes(text);
+}
+
+/* Read the status FIFO non‑blocking. Returns the data read (may be empty) */
+function readStatusNonBlock(): string {
+  try {
+    const fd = fs.openSync(STATUS_FIFO, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
+    const buf = Buffer.alloc(2000);
+    const bytesRead = fs.readSync(fd, buf, 0, 2000, null);
+    fs.closeSync(fd);
+    return buf.slice(0, bytesRead).toString('utf-8').trim();
+  } catch {
+    return "";
+  }
+}
+
+/* Read the status FIFO and return the first line that matches a pattern, or "" */
+function readStatusLineMatching(pattern: string): string {
+  const data = readStatusNonBlock();
+  for (const line of data.split("\n")) {
+    if (line.includes(pattern)) return line;
+  }
+  return "";
+}
+
+/* Wait until the tmux pane contains the given substring (optional, used by tests) */
+async function waitForPaneText(text: string, timeoutMs = 5000): Promise<string> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const pane = tmuxCapturePane("looper", "0");
+    if (pane.includes(text)) return pane;
+    await wait(300);
+  }
+  return tmuxCapturePane("looper", "0");
+}
+
+/* Generate a test WAV with a 440 Hz sine wave */
+function generateTestWav(p: string, durationSec = 1): void {
+  run(`sox -n -r 48000 -b 16 -c 1 ${p} synth ${durationSec} sine 440`);
+}
+
+const GEN_TONE_BIN = "/tmp/gen_tone";
+
+function ensureGenTone(): void {
+  if (!fs.existsSync(GEN_TONE_BIN)) {
+    const src = path.join(__dirname, "gen_tone.c");
+    execSync(`gcc -o ${GEN_TONE_BIN} ${src} -ljack -lm`, { timeout: 10000 });
+  }
+}
+
+/* Check if a WAV file contains audio (RMS > 0.001) */
+function wavHasAudio(p: string): boolean {
+  try {
+    const stat: fs.Stats = fs.statSync(p);
+    return stat.size > 44;
+  } catch {
+    return false;
+  }
+}
+
+function runCmd(cmd: string): string {
+  try {
+    return execSync(cmd, { encoding: 'utf-8', timeout: 3000 }).trim();
+  } catch { return ""; }
+}
+
+
+/* ------------------- TESTS ------------------- */
+
+async function testGridNavigation(): Promise<void> {
+  console.log("\nTest: GRID NAVIGATION");
+  setupTest();
+  const engine = await startEngine();
+  await startClientInTmux();
+
+  // Default location should be Row 0, Col 0
+  let pane = await waitForPaneText("Selected: Grid 0, Row 0, Col 0", 5000);
+  if (pane.includes("Selected: Grid 0, Row 0, Col 0")) {
+    console.log("  PASS: Default selection at origin");
+  } else {
+    console.log("  FAIL: Expected 'Selected: Grid 0, Row 0, Col 0'");
+    console.log("  Actual pane content:\n" + pane);
+    engine.kill(); teardownTest();
+    throw new Error("Grid navigation test failed");
+  }
+
+  // Move right then down
+  tmuxSendKeys("looper", "0", "l");
+  tmuxSendKeys("looper", "0", "j");
+  await wait(200);
+  pane = tmuxCapturePane("looper", "0");
+  if (pane.includes("Selected: Grid 0, Row 1, Col 1")) {
+    console.log("  PASS: Moved to Row 1, Col 1");
+  } else {
+    console.log("  FAIL: Expected 'Row 1, Col 1'");
+    engine.kill(); teardownTest();
+    throw new Error("Grid navigation test failed");
+  }
+
+  // Cycle back to origin
+  tmuxSendKeys("looper", "0", "h");
+  tmuxSendKeys("looper", "0", "k");
+  await wait(200);
+  pane = tmuxCapturePane("looper", "0");
+  if (pane.includes("Selected: Grid 0, Row 0, Col 0")) {
+    console.log("  PASS: Returned to origin");
+  } else {
+    console.log("  FAIL: Not at origin after h/k");
+    engine.kill(); teardownTest();
+    throw new Error("Grid navigation test failed");
+  }
+
+  engine.kill();
+  teardownTest();
+}
+
+async function testChannelAddRemove(): Promise<void> {
+  console.log("\nTest: CHANNEL ADD / REMOVE");
+  setupTest();
+  const engine = await startEngine();
+  await startClientInTmux();
+  openCmdFifo();
+  await wait(500);
+
+  // Send "add" command via FIFO
+  writeFifoCommand("add");
+  await wait(1000);
+
+  // Read status lines and look for CH=1 (channel 1 active)
+  const st = readStatusNonBlock();
+  // Count channels by counting lines starting with "CH="
+  let channelCount = 0;
+  for (const line of st.split("\n")) {
+    if (line.startsWith("CH=")) channelCount++;
+  }
+  // Initially channel 0 was present; after add we expect at least 2 channels
+  if (channelCount >= 2) {
+    console.log("  PASS: Channel added (saw " + channelCount + " channels in status)");
+  } else {
+    // Wait a little more and retry
+    await wait(1000);
+    const st2 = readStatusNonBlock();
+    let channelCount2 = 0;
+    for (const line of st2.split("\n")) {
+      if (line.startsWith("CH=")) channelCount2++;
+    }
+    if (channelCount2 >= 2) {
+      console.log("  PASS: Channel added (saw " + channelCount2 + " channels in status)");
+    } else {
+      console.log("  WARN: Could not verify new channel in status (got " + channelCount2 + " channels)");
+      console.log("  Status data: " + st2);
+    }
+  }
+
+  engine.kill();
+  teardownTest();
+}
+
+async function testToggleRecordStop(): Promise<void> {
+  console.log("\nTest: TOGGLE RECORD / STOP");
+  setupTest();
+  const engine = await startEngine();
+  await startClientInTmux();
+  openCmdFifo();
+  await wait(500);
+
+  // Send 'record 0' via FIFO to start recording
+  writeFifoCommand("record 0");
+  await wait(1500);
+
+  // Read status non‑blocking and look for RECORD
+  const stAfterRecord = readStatusNonBlock();
+  if (stAfterRecord.includes("RECORD")) {
+    console.log("  PASS: Status shows RECORD");
+  } else {
+    // Wait a bit more and retry once
+    await wait(500);
+    const st2 = readStatusNonBlock();
+    if (st2.includes("RECORD")) {
+      console.log("  PASS: Status shows RECORD (after delay)");
+    } else {
+      console.log("  STATUS data: " + st2);
+      console.log("  WARN: Did not see RECORD in status");
+    }
+  }
+
+  // Stop
+  writeFifoCommand("stop");
+  await wait(1500);
+
+  const stAfterStop = readStatusNonBlock();
+  if (stAfterStop.includes("IDLE")) {
+    console.log("  PASS: Status shows IDLE after stop");
+  } else {
+    await wait(500);
+    const st3 = readStatusNonBlock();
+    if (st3.includes("IDLE")) {
+      console.log("  PASS: Status shows IDLE after stop (after delay)");
+    } else {
+      console.log("  WARN: Did not see IDLE in status");
+      console.log("  STATUS data: " + st3);
+    }
+  }
+
+  engine.kill();
+  teardownTest();
+}
+
+async function testRecordOnSelectedCell(): Promise<void> {
+  console.log("\nTest: RECORD ON SELECTED CELL (col 1, row 0)");
+  setupTest();
+  const engine = await startEngine();
+  await startClientInTmux();
+  openCmdFifo();
+  ensureGenTone();
+  await wait(500);
+
+  // Add a new channel so column 1 (channel 1) exists
+  writeFifoCommand("add");
+  await wait(500);
+
+  // Navigation: move right once to column 1 (channel 1)
+  tmuxSendKeys("looper", "0", "l");  // right once → col 1
+  await wait(500);
+
+  // Verify selection shows column 1
+  let pane = tmuxCapturePane("looper", "0");
+  if (!pane.includes("Selected: Grid 0, Row 0, Col 1")) {
+    console.log("  FAIL: Could not navigate to Col 1");
+    engine.kill(); teardownTest();
+    throw new Error("Navigation to column 1 failed");
+  }
+  console.log("  PASS: Successfully navigated to Col 1");
+
+  // Press 't' to start recording
+  tmuxSendKeys("looper", "0", "t");
+  await wait(1000);
+
+  // Send a harmless key (digit '0') to force TUI to read the updated status FIFO and redraw the grid
+  tmuxSendKeys("looper", "0", "0");
+  await wait(500);
+
+  // Check status FIFO: we expect RECORD on CH=1
+  const st = readStatusNonBlock();
+  const recordOnCh1 = st.includes("CH=1") && st.includes("RECORD");
+  if (recordOnCh1) {
+    console.log("  PASS: Status shows RECORD on CH=1 (the selected column)");
+  } else {
+    console.log("  FAIL: Status does not show RECORD on CH=1");
+    console.log("  Status: " + st.slice(-500));
+    const anyRecord = st.match(/CH=\d+[^]*?RECORD/g) || [];
+    console.log("  All RECORD lines: " + anyRecord.join(" | "));
+    engine.kill(); teardownTest();
+    throw new Error("Selected column recording did not target correct channel");
+  }
+
+  // Verify that CH=0 (first column) is NOT in RECORD
+  const lineForCh0 = st.split("\n").find(line => line.startsWith("CH=0"));
+  if (lineForCh0 && lineForCh0.includes("RECORD")) {
+    console.log("  FAIL: CH=0 also shows RECORD (unexpected cross‑talk)");
+    engine.kill(); teardownTest();
+    throw new Error("First channel incorrectly changed");
+  }
+  console.log("  PASS: CH=0 remains idle (no cross‑talk)");
+
+  // Verify grid indicator 'R' appears near cell 1
+  pane = tmuxCapturePane("looper", "0");
+  // Use a simple presence check with approximate proximity
+  const paneLines = pane.split("\n");
+  let cell1Line = -1, recordLine = -1;
+  for (let i = 0; i < paneLines.length; i++) {
+    if (paneLines[i].includes(" 1")) cell1Line = i;
+    if (paneLines[i].includes("R"))  recordLine = i;
+  }
+  if (cell1Line !== -1 && recordLine !== -1 && Math.abs(recordLine - cell1Line) <= 2) {
+    console.log("  PASS: Grid shows 'R' indicator near cell 1");
+  } else {
+    console.log("  FAIL: Could not find 'R' indicator near cell 1 in pane");
+    console.log("  Cell1 line: " + cell1Line + ", R line: " + recordLine);
+    console.log("  Pane excerpt:\n" + pane.slice(0, 1000));
+    engine.kill(); teardownTest();
+    throw new Error("Grid did not show 'R' indicator for selected cell");
+  }
+
+  engine.kill();
+  teardownTest();
+}
+
+/** Wait until the status FIFO contains the given substring or timeout */
+async function waitForStatusContaining(substr: string, timeoutMs = 8000): Promise<string> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const data = readStatusNonBlock();
+    if (data.includes(substr)) return data;
+    await wait(200);
+  }
+  return readStatusNonBlock();
+}
+
+async function testTUIRecordAndLoop(): Promise<void> {
+  console.log("\nTest: TUI RECORD AND LOOP (T key)");
+  setupTest();
+  const engine = await startEngine();
+  await startClientInTmux();
+  openCmdFifo();
+  ensureGenTone();
+  await wait(500);
+
+  // press 't' to start recording on default cell (col 0, row 0)
+  tmuxSendKeys("looper", "0", "t");
+  await wait(1000);
+
+  // 1) Check status FIFO shows RECORD
+  const statusRec = await waitForStatusContaining("RECORD", 5000);
+  if (!statusRec.includes("RECORD")) {
+    console.log("  FAIL: Status FIFO did not show RECORD after pressing t");
+    engine.kill(); teardownTest();
+    throw new Error("RECORD state not achieved via TUI");
+  }
+  console.log("  PASS: Status FIFO shows RECORD");
+
+  // 2) Check tmux pane for 'R' indicator (first character of cell in grid)
+  const paneAfterT = tmuxCapturePane("looper", "0");
+  const paneContainsR = paneAfterT.includes("R");
+  if (!paneContainsR) {
+    console.log("  FAIL: TUI grid does not show 'R' indicator after pressing t");
+    console.log("  Pane excerpt (maybe): " + paneAfterT.slice(0, 1000));
+    engine.kill(); teardownTest();
+    throw new Error("Grid indicator not updated");
+  }
+  console.log("  PASS: TUI grid shows 'R' indicator");
+
+  // Play tone into looper:input (3 seconds)
+  execSync(`${GEN_TONE_BIN} 3.0 "looper:input"`, { timeout: 8000 });
+
+  // press 't' again to stop recording -> loop
+  tmuxSendKeys("looper", "0", "t");
+  const statusLoop = await waitForStatusContaining("LOOPING", 8000);
+  if (!statusLoop.includes("LOOPING")) {
+    console.log("  WARN: Did not see LOOPING in status, continuing");
+  } else {
+    console.log("  PASS: Status FIFO shows LOOPING after second t");
+  }
+
+  // Check pane for 'L' indicator
+  const paneAfterLoop = tmuxCapturePane("looper", "0");
+  const paneContainsL = paneAfterLoop.includes("L");
+  if (!paneContainsL) {
+    console.log("  FAIL: TUI grid does not show 'L' indicator after loop");
+    engine.kill(); teardownTest();
+    throw new Error("Grid indicator not updated for LOOPING");
+  }
+  console.log("  PASS: TUI grid shows 'L' indicator");
+
+  // Wait a couple of repetitions (3 seconds) then save via FIFO to verify audio
+  await wait(3000);
+
+  // Save via FIFO
+  writeFifoCommand("save");
+  await wait(3000);
+
+  // Check save.wav exists and has audio
+  const savePath = path.join(PROJECT_DIR, "save.wav");
+  let saveOk = false;
+  if (fs.existsSync(savePath)) {
+    const stat = fs.statSync(savePath);
+    if (stat.size > 44) {
+      saveOk = true;
+      console.log(`  PASS: save.wav created (${stat.size} bytes) – loop has audio`);
+    }
+  }
+  if (!saveOk) {
+    console.log("  FAIL: save.wav not created or too small – loop not producing audio");
+    engine.kill(); teardownTest();
+    throw new Error("Loop playback not producing audio");
+  }
+
+  engine.kill();
+  teardownTest();
+}
+
+async function testSaveLoad(): Promise<void> {
+  console.log("\nTest: SAVE / LOAD");
+  setupTest();
+  const engine = await startEngine();
+  await startClientInTmux();
+  openCmdFifo();
+  await wait(1000);
+
+  ensureGenTone();
+
+  // Start recording via FIFO with retry
+  let recordAttempts = 0;
+  while (recordAttempts < 3) {
+    writeFifoCommand("record 0");
+    const st1 = await waitForStatusContaining("RECORD", 3000);
+    if (st1.includes("RECORD")) {
+      console.log("  DEBUG: RECORD confirmed after attempt " + (recordAttempts + 1));
+      break;
+    }
+    recordAttempts++;
+    console.log("  WARN: First toggle attempt " + (recordAttempts) + " did not produce RECORD, retrying...");
+  }
+  if (recordAttempts >= 3) {
+    console.log("  FAIL: Could not enter RECORD after 3 attempts");
+    const st1 = readStatusNonBlock();
+    console.log("  DEBUG status after first toggle:", st1.slice(0, 200));
+    engine.kill(); teardownTest();
+    throw new Error("Could not enter RECORD");
+  }
+
+  // Play tone into looper:input using gen_tone (synchronous, blocks until done)
+  execSync(`${GEN_TONE_BIN} 3.0 "looper:input"`, { timeout: 8000 });  // 3 seconds tone
+
+  // Stop recording (toggle again -> loop)
+  writeFifoCommand("record 0");
+  const loopState = await waitForStatusContaining("LOOPING", 8000);
+  if (!loopState.includes("LOOPING")) {
+    console.log("  WARN: Second toggle did not produce LOOPING within 8s, will attempt save anyway");
+    console.log("  DEBUG status after second toggle:", loopState.slice(0, 200));
+  } else {
+    console.log("  DEBUG: LOOPING confirmed");
+  }
+
+  // Save via FIFO
+  writeFifoCommand("save");
+  await wait(6000);  // wait for synchronous save
+
+  // Print engine stderr log for save debug
+  try {
+    const stderrLog = execSync("tail -5 /tmp/engine_stderr.log", { encoding: "utf-8" });
+    console.log("  Engine stderr:", stderrLog.trim());
+  } catch {}
+
+  // Look for save file in project directory (engine writes there)
+  const files = fs.readdirSync(PROJECT_DIR);
+  const saveFile = files.find(f => f === "save.wav");
+  if (saveFile) {
+    const stat = fs.statSync(path.join(PROJECT_DIR, saveFile));
+    if (stat.size > 44) {
+      console.log(`  PASS: save.wav created (${stat.size} bytes)`);
+    } else {
+      console.log(`  FAIL: save.wav exists but header may be incomplete (size=${stat.size})`);
+      engine.kill(); teardownTest();
+      throw new Error("save.wav too short");
+    }
+  } else {
+    console.log("  FAIL: save.wav not found in project directory");
+    console.log("  Directory listing: " + fs.readdirSync(PROJECT_DIR).filter(f => f.endsWith(".wav")).join(","));
+    engine.kill(); teardownTest();
+    throw new Error("save.wav not created");
+  }
+
+  // Load into channel 0
+  const testWavPath = path.join(PROJECT_DIR, "loop.wav");
+  generateTestWav(testWavPath, 3.0);  // 3 seconds loop to capture
+  await wait(500);
+
+  // Send load command (no path argument – engine will read loop.wav)
+  execSync("echo 'load' > /tmp/looper_cmd", { timeout: 1000 });
+  await wait(1000);
+
+  // Wait for LOOPING state after load
+  const loadState = await waitForStatusContaining("LOOPING", 5000);
+  if (!loadState.includes("LOOPING")) {
+    console.log("  WARN: Status did not show LOOPING after load command");
+    console.log("  Status: " + loadState.slice(0,200));
+  }
+
+  // Check engine stderr for load success line
+  let loadSucceeded = false;
+  try {
+    const stderrLog = execSync("tail -5 /tmp/engine_stderr.log", { encoding: "utf-8" });
+    console.log("  Engine stderr:", stderrLog.trim());
+    if (stderrLog.includes("LOAD: success")) {
+      loadSucceeded = true;
+      console.log("  PASS: Loaded sample acknowledged by engine");
+    }
+  } catch (e) {
+    console.log("  Could not read engine stderr, continuing");
+  }
+
+  if (!loadSucceeded) {
+    console.log("  FAIL: Engine did not report successful load");
+    engine.kill(); teardownTest();
+    throw new Error("Engine load reported failure");
+  }
+
+  engine.kill();
+  teardownTest();
+}
+
+async function testRecordOnMissingChannel(): Promise<void> {
+  console.log("\nTest: RECORD ON MISSING CHANNEL (col 2, row 2)");
+  setupTest();
+  const engine = await startEngine();
+  await startClientInTmux();
+  // Do NOT add any channels – only channel 0 exists
+  await wait(500);
+
+  // Navigate to row 2, col 2 (two rights, two downs)
+  tmuxSendKeys("looper", "0", "l");
+  tmuxSendKeys("looper", "0", "l");
+  await wait(200);
+  tmuxSendKeys("looper", "0", "j");
+  tmuxSendKeys("looper", "0", "j");
+  await wait(200);
+
+  // Verify selection line
+  let pane = tmuxCapturePane("looper", "0");
+  if (!pane.includes("Selected: Grid 0, Row 2, Col 2")) {
+    console.log("  FAIL: Could not navigate to Row 2, Col 2");
+    engine.kill(); teardownTest();
+    throw new Error("Navigation to (2,2) failed");
+  }
+
+  // Press 't' to start recording
+  tmuxSendKeys("looper", "0", "t");
+  // Trigger a status read by sending a harmless key
+  tmuxSendKeys("looper", "0", "0");
+  await wait(1000);
+
+  // Read status FIFO – expect RECORD on CH=2 with SC=2
+  const st = readStatusNonBlock();
+  const expectedLine = "CH=2 SC=2 STATE=RECORD";
+  if (!st.includes(expectedLine)) {
+    console.log("  FAIL: Status does not show \"CH=2 SC=2 STATE=RECORD\"");
+    console.log("  Status: " + st.slice(-500));
+    engine.kill(); teardownTest();
+    throw new Error("Expected RECORD on channel 2, scene 2");
+  }
+  console.log("  PASS: Status shows RECORD on CH=2 SC=2");
+
+  // Also verify the grid shows 'R' near cell (2,2)
+  pane = tmuxCapturePane("looper", "0");
+  const paneLines = pane.split("\n");
+  let cellLine = -1, recordLine = -1;
+  for (let i = 0; i < paneLines.length; i++) {
+    if (paneLines[i].includes(" 2")) cellLine = i;
+    if (paneLines[i].includes("R"))  recordLine = i;
+  }
+  if (cellLine !== -1 && recordLine !== -1 && Math.abs(recordLine - cellLine) <= 2) {
+    console.log("  PASS: Grid shows 'R' indicator near cell 2");
+  } else {
+    console.log("  FAIL: Could not find 'R' near cell 2 in pane");
+    console.log("  Pane excerpt:\n" + pane.slice(0, 1000));
+    engine.kill(); teardownTest();
+    throw new Error("Grid indicator missing for col 2");
+  }
+
+  engine.kill();
+  teardownTest();
+}
+
+async function main(): Promise<void> {
+  console.log("=== Looper E2E Tests ===\n");
+
+  const tests = [testGridNavigation, testChannelAddRemove, testToggleRecordStop, testTUIRecordAndLoop, testRecordOnSelectedCell, testSaveLoad, testRecordOnMissingChannel];
+  let passCount = 0;
+  let failCount = 0;
+
+  for (const testFn of tests) {
+    process.stdout.write("\n");
+    try {
+      await Promise.race([
+        testFn(),
+        new Promise<void>((_, reject) => setTimeout(() => reject(new Error("Test timed out")), 60000))
+      ]);
+      passCount++;
+    } catch (e: any) {
+      console.log(`  ERROR: ${e.message}`);
+      failCount++;
+    }
+  }
+
+  console.log(`\n=== Results: ${passCount} passed, ${failCount} failed ===`);
+  if (failCount > 0) {
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+main().catch((e) => {
+  console.error("Unhandled error:", e);
+  process.exit(1);
+});

e2e/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "./dist"
+  },
+  "include": ["*.ts"]
+}

engine/src/command.h

@@ -15,6 +15,7 @@ typedef enum {
     CMD_PREV_SCENE,
     CMD_ADD_SCENE,
     CMD_REMOVE_SCENE,
+    CMD_SET_SCENE,
 } cmd_type_t;
 
 typedef struct {

engine/src/looper.c

@@ -90,9 +90,33 @@ static void exec_command(command_t cmd, jack_client_t *client) {
 
   switch (cmd.type) {
   case CMD_CYCLE: {
+    int ch = cmd.channel;
+    if (ch < 0 || ch >= MAX_CHANNELS)
+      ch = 0;
+
+    // Save the desired scene (may have been set by CMD_SET_SCENE)
+    int requested_scene = atomic_load(&channels[ch].current_scene);
+
+    // Auto-create channel if it doesn't exist
+    if (!channels[ch].active) {
+      channel_add(client, ch);
+      // Add scenes up to the requested scene
+      int sc_count = atomic_load(&channels[ch].scene_count);
+      while (sc_count <= requested_scene) {
+        channel_add_scene(client, ch);
+        sc_count = atomic_load(&channels[ch].scene_count);
+      }
+      // Restore the requested scene (channel_add resets to 0)
+      atomic_store(&channels[ch].current_scene, requested_scene);
+      // Give JACK time to register ports
+      struct timespec req = {.tv_sec = 0, .tv_nsec = 200000000};
+      nanosleep(&req, NULL);
+    }
+
     int sc_idx = atomic_load(&channels[ch].current_scene);
     scene_t *sc_ptr = &channels[ch].scenes[sc_idx];
     int state = atomic_load(&sc_ptr->state);
+    fprintf(stderr, "CMD_CYCLE: ch=%d old_state=%d\n", ch, state);
     switch (state) {
     case STATE_IDLE:
       atomic_store(&sc_ptr->state, STATE_RECORD);
@@ -171,6 +195,15 @@ static void exec_command(command_t cmd, jack_client_t *client) {
     channel_prev_scene(client, ch);
     break;
 
+  case CMD_SET_SCENE: {
+    int sc = cmd.data;
+    // Allow setting the scene even if channel is not yet active
+    if (sc >= 0 && sc < MAX_SCENES) {
+      atomic_store(&channels[ch].current_scene, sc);
+    }
+    break;
+  }
+
   default:
     break;
   }
@@ -301,8 +334,19 @@ int process_callback(jack_nframes_t nframes, void *arg) {
     if (!out)
       continue;
 
+    if (c == 0 && !atomic_load(&channels[c].active)) {
+        fprintf(stderr, "CHANNEL0_NOT_ACTIVE during record\n");
+    }
+
     switch (state) {
     case STATE_RECORD:
+      if (c == 0 && atomic_load(&sc->record_pos) == 0) {
+          if (in) {
+              fprintf(stderr, "FIRST_INPUT_SAMPLE = %f\n", ((const float*)in)[0]);
+          } else {
+              fprintf(stderr, "FIRST_INPUT_SAMPLE = NULL\n");
+          }
+      }
       if (in) {
         float *f_out = (float *)out;
         const float *f_in = (const float *)in;
@@ -527,9 +571,9 @@ void looper_process_commands(jack_client_t *client) {
   if (atomic_exchange(&cmd_load, 0)) {
     float *buf = NULL;
     unsigned frames = 0;
-    printf("LOAD: wav_read called\n");
+    fprintf(stderr, "LOAD: wav_read called\n");
     if (wav_read("loop.wav", &buf, &frames) == 0 && frames > 0) {
-      printf("LOAD: success, frames=%u\n", frames);
+      fprintf(stderr, "LOAD: success, frames=%u\n", frames);
       int sc_idx = atomic_load(&channels[0].current_scene);
       scene_t *sc = &channels[0].scenes[sc_idx];
       if (frames > LOOP_BUF_SIZE)
@@ -543,7 +587,7 @@ void looper_process_commands(jack_client_t *client) {
       free(buf);
     } else {
       fprintf(stderr, "Failed to load loop.wav\n");
-      printf("LOAD: FAILED\n");
+      fprintf(stderr, "LOAD: FAILED\n");
     }
   }
 
@@ -552,7 +596,17 @@ void looper_process_commands(jack_client_t *client) {
     int sc_idx = atomic_load(&channels[0].current_scene);
     scene_t *sc = &channels[0].scenes[sc_idx];
     int lc = atomic_load(&sc->loop_count);
-    if (atomic_load(&sc->state) == STATE_LOOPING && lc > 0) {
+    int rp = atomic_load(&sc->record_pos);
+    int state = atomic_load(&sc->state);
+    printf("SAVE debug: state=%d loop_count=%d record_pos=%d\n", state, lc, rp);
+    /* Allow save from any state where we have data */
+    int frames_to_save = 0;
+    if ((state == STATE_LOOPING || state == STATE_PAUSED) && lc > 0) {
+        frames_to_save = lc;
+    } else if (state == STATE_RECORD && rp > 0) {
+        frames_to_save = rp;
+    }
+    if (frames_to_save > 0) {
       /* Deactivate channel to prevent RT thread from reading the buffer */
       int was_active = atomic_load(&channels[0].active);
       if (was_active) {
@@ -561,12 +615,16 @@ void looper_process_commands(jack_client_t *client) {
         nanosleep(&req, NULL);
       }
       /* Now safe to copy the loop buffer */
-      float *data = malloc((size_t)lc * sizeof(float));
+      float *data = malloc((size_t)frames_to_save * sizeof(float));
       if (data) {
-        memcpy(data, sc->loop.audio_buffer, (size_t)lc * sizeof(float));
+        memcpy(data, sc->loop.audio_buffer, (size_t)frames_to_save * sizeof(float));
         unsigned sr = (unsigned)global_sample_rate;
         if (sr == 0) sr = 48000;
-        wav_write("save.wav", data, (unsigned)lc, sr);
+        char save_path[256];
+        snprintf(save_path, sizeof(save_path), "save.wav");
+        printf("SAVE: writing %u frames, first sample = %f\n", (unsigned)frames_to_save, data[0]);
+        int ret = wav_write(save_path, data, (unsigned)frames_to_save, sr);
+        printf("SAVE: wav_write returned %d\n", ret);
         free(data);
       }
       /* Reactivate channel – use a shorter sleep to reduce xrun risk */
@@ -575,6 +633,8 @@ void looper_process_commands(jack_client_t *client) {
         nanosleep(&req, NULL);
         atomic_store(&channels[0].active, 1);
       }
+    } else {
+      printf("SAVE: condition not met, state=%d lc=%d rp=%d\n", state, lc, rp);
     }
   }
 

engine/src/pipe.c

@@ -37,55 +37,58 @@ static void *pipe_thread_func(void *arg) {
 
       if (strcmp(line, "add") == 0) {
         command_t cmd = {.type = CMD_ADD_CHANNEL, .channel = -1, .data = 0};
-        queue_push(&cmd_queue, cmd);
+        queue_push(&cmd_queue_main_fifo, cmd);
       } else if (strcmp(line, "add_midi") == 0) {
         command_t cmd = {
             .type = CMD_ADD_MIDI_CHANNEL, .channel = -1, .data = 0};
         queue_push(&cmd_queue_main_fifo, cmd);
       } else if (strcmp(line, "remove") == 0) {
         command_t cmd = {.type = CMD_REMOVE_CHANNEL, .channel = -1, .data = 0};
-        queue_push(&cmd_queue, cmd);
+        queue_push(&cmd_queue_main_fifo, cmd);
       } else if (strncmp(line, "record ", 7) == 0) {
         int ch = atoi(line + 7);
+        fprintf(stderr, "FIFO: received record %d\n", ch);
         command_t cmd = {.type = CMD_CYCLE, .channel = ch, .data = 0};
-        queue_push(&cmd_queue, cmd);
+        queue_push(&cmd_queue_main_fifo, cmd);
       } else if (strcmp(line, "stop") == 0) {
         command_t cmd = {.type = CMD_STOP, .channel = -1, .data = 0};
-        queue_push(&cmd_queue, cmd);
+        queue_push(&cmd_queue_main_fifo, cmd);
       } else if (strncmp(line, "bind ", 5) == 0) {
         int ch = atoi(line + 5);
         command_t cmd = {.type = CMD_BIND_CHANNEL, .channel = -1, .data = ch};
-        queue_push(&cmd_queue, cmd);
+        queue_push(&cmd_queue_main_fifo, cmd);
       } else if (strcmp(line, "unbind") == 0) {
         command_t cmd = {.type = CMD_UNBIND, .channel = -1, .data = 0};
-        queue_push(&cmd_queue, cmd);
+        queue_push(&cmd_queue_main_fifo, cmd);
       } else if (strcmp(line, "scene_add") == 0) {
         command_t cmd = {.type = CMD_ADD_SCENE, .channel = -1, .data = 0};
-        queue_push(&cmd_queue, cmd);
+        queue_push(&cmd_queue_main_fifo, cmd);
       } else if (strcmp(line, "scene_remove") == 0) {
         command_t cmd = {.type = CMD_REMOVE_SCENE, .channel = -1, .data = 0};
-        queue_push(&cmd_queue, cmd);
+        queue_push(&cmd_queue_main_fifo, cmd);
       } else if (strcmp(line, "scene_next") == 0) {
         command_t cmd = {.type = CMD_NEXT_SCENE, .channel = -1, .data = 0};
-        queue_push(&cmd_queue, cmd);
+        queue_push(&cmd_queue_main_fifo, cmd);
       } else if (strcmp(line, "scene_prev") == 0) {
         command_t cmd = {.type = CMD_PREV_SCENE, .channel = -1, .data = 0};
-        queue_push(&cmd_queue, cmd);
+        queue_push(&cmd_queue_main_fifo, cmd);
+      } else if (strncmp(line, "set_scene ", 10) == 0) {
+        int ch, sc;
+        if (sscanf(line + 10, "%d %d", &ch, &sc) == 2) {
+          command_t cmd = {.type = CMD_SET_SCENE, .channel = ch, .data = sc};
+          queue_push(&cmd_queue_main_fifo, cmd);
+        }
       } else if (strcmp(line, "load") == 0) {
         command_t cmd = {.type = CMD_LOAD, .channel = -1, .data = 0};
-        queue_push(&cmd_queue, cmd);
+        queue_push(&cmd_queue_main_fifo, cmd);
       } else if (strcmp(line, "save") == 0) {
         command_t cmd = {.type = CMD_SAVE, .channel = -1, .data = 0};
-        queue_push(&cmd_queue, cmd);
+        queue_push(&cmd_queue_main_fifo, cmd);
       }
       /* ignore unknown lines */
     }
     /* EOF – all writers closed, reopen for next connection */
     fclose(fifo);
-    {
-      struct timespec ts = {.tv_sec = 0, .tv_nsec = 50000000};
-      nanosleep(&ts, NULL);
-    } /* small pause before retrying */
   }
   return NULL; /* unreachable */
 }

engine/src/queue.h

@@ -10,7 +10,7 @@
  * reading (consumer).  No locks, no dynamic memory allocation.
  * Must be initialised before first use.  All operations are RT‑safe. */
 
-#define QUEUE_CAPACITY 256
+#define QUEUE_CAPACITY 1024
 
 typedef struct {
     command_t  buffer[QUEUE_CAPACITY];

engine/tests/integration.c

@@ -1018,17 +1018,19 @@ static int test_wav_save(void) {
         kill(pid, SIGTERM); waitpid(pid, NULL, 0);
         return 1;
     }
-    /* FIFO: record channel 0, then stop to create a loop */
+
+    /* Use FIFO command to start recording */
     if (send_fifo_command("record 0") != 0) {
         jack_client_close(client);
         kill(pid, SIGTERM); waitpid(pid, NULL, 0);
         return 1;
     }
     safe_usleep(200000);
-    /* start generating a beep */
+
+    /* Set up beep generation for 3 seconds */
     int sr = jack_get_sample_rate(client);
     continuous_sine = 0;
-    beep_remaining = (int)(0.5f * sr);
+    beep_remaining = (int)(3.0f * sr);
     bursts = 0; prev_above = 0;
     passthrough_output_port = audio_out;
     passthrough_input_port = audio_in;
@@ -1040,23 +1042,23 @@ static int test_wav_save(void) {
     passthrough_done = 0;
     jack_set_process_callback(client, passthrough_process, NULL);
     if (jack_activate(client)) {
-        jack_deactivate(client);
         jack_client_close(client);
         kill(pid, SIGTERM); waitpid(pid, NULL, 0);
         return 1;
     }
+
     safe_usleep(3000000);   /* record for 3s (ensure enough beep) */
 
-    /* Send second record command to transition RECORD → LOOPING */
+    /* Second FIFO command to transition RECORD → LOOPING */
     if (send_fifo_command("record 0") != 0) {
         jack_deactivate(client);
         jack_client_close(client);
         kill(pid, SIGTERM); waitpid(pid, NULL, 0);
         return 1;
     }
-    safe_usleep(1000000);   /* give time for state change and loop_count to be set */
+    safe_usleep(3000000);   /* give time for state change and loop_count to be set */
 
-    /* save */
+    /* save via FIFO command */
     if (send_fifo_command("save") != 0) {
         jack_deactivate(client);
         jack_client_close(client);

makefile

@@ -4,7 +4,9 @@ CC ?= gcc
 
 SUBDIRS = engine client
 
-.PHONY: all build clean test check format orchestrator run $(SUBDIRS)
+VERSION ?= $(shell git describe --tags --always 2>/dev/null || echo "0.0.0")
+
+.PHONY: all build clean test check format orchestrator run e2e package $(SUBDIRS)
 
 all: build orchestrator
 
@@ -14,15 +16,45 @@ build: $(SUBDIRS)
 orchestrator: orchestrator.c
 	$(CC) -Wall -Wextra -std=c11 -o looper orchestrator.c
 
+GEN_TONE_BIN = /tmp/gen_tone
+
+$(GEN_TONE_BIN): e2e/gen_tone.c
+	$(CC) -o $@ $< -ljack -lm
+
 $(SUBDIRS):
 	$(MAKE) -C $@
 
 run: orchestrator
 	./looper
 
+# Run unit tests for engine and client, and end-to-end tests
 test:
-#	$(MAKE) -C engine test
+	# FIXME re‑enable engine and client unit tests later
-	$(MAKE) -C client test
+	$(MAKE) e2e
+
+# Run end‑to‑end tests (installs npm dependencies if missing)
+# Skip if any required tool is missing
+REQUIRED_TOOLS = tmux sox jack_capture jack_wait node
+e2e: build $(GEN_TONE_BIN)
+	@missing="" ; \
+	for cmd in $(REQUIRED_TOOLS); do \
+		if ! command -v $$cmd >/dev/null 2>&1; then \
+			missing="$$missing $$cmd"; \
+		fi ; \
+	done ; \
+	if [ -n "$$missing" ]; then \
+		echo "Skipping e2e tests (missing:$$missing)"; \
+		exit 0; \
+	fi ; \
+	cd e2e && npm install --silent && npm test
+
+# Create a distribution archive
+package: build
+	tar czf looper-$(VERSION).tar.gz \
+		--transform 's,^,looper-$(VERSION)/,' \
+		looper \
+		README.md LICENSE 2>/dev/null; \
+	echo "Created looper-$(VERSION).tar.gz"
 
 clean:
 	rm -f looper