chore: Add pre-push hooks

Co-authored-by: aider (deepseek/deepseek-reasoner) <aider@aider.chat>

docs/1-multichannel.md

@@ -0,0 +1,72 @@
+# Multi‑Channel & Bind Feature
+
+The looper supports up to 16 independent channels (numbered 0–15).  
+Channel 0 is always present and connected to the `looper:input` / `looper:output` audio ports.  
+Additional channels can be created and removed dynamically using MIDI commands.
+
+## MIDI Ports
+
+- **`looper:control`** – receives MIDI note‑on events for channel management and state toggling.
+- **`looper:clock`** – receives MIDI clock messages (0xFA, 0xFC, 0xFB) that affect channel 0 only.
+
+## Control‑Key Modifier
+
+Hold the **control key** (MIDI note 64) pressed *before* sending another note to put the looper in “command mode”.  
+While control‑key is active, the next note‑on (with velocity > 0) performs a special action instead of its direct mapping.  
+The control key is released either by sending note‑off (note 64 or any note) or by sending a note‑on while control‑key is already active (the action is performed and control‑key is cleared).
+
+## Available Commands (under control key)
+
+| Note | Action                                                                                       |
+|------|----------------------------------------------------------------------------------------------|
+| 0–15 | **Bind** the next `control+62` toggle to the channel with that index.                       |
+| 60   | **Add** a new dynamic channel (creates `channelX_input` / `channelX_output` ports).         |
+| 61   | **Remove** the highest‑numbered active channel (excluding channel 0).                       |
+| 62   | **Toggle** the current bound channel through its state machine:                              |
+|      | IDLE → RECORD → LOOPING → PAUSED → LOOPING → … (each press advances one step).              |
+| 63   | **Unbind** – reset the bound channel back to **0**.                                          |
+
+> **Notes:**
+> - The default bound channel is **0**. If you never send a bind command, `control+62` controls channel 0.
+> - To bind a different channel, send `control + note <16>` (e.g., control + note 5 binds channel 5).
+> - Bind is sticky – it stays until overwritten by another bind command.
+> - To **unbind** (reset to channel 0), send `control + note 63`.
+
+## Direct Mapping (without control key)
+
+For backward compatibility, the following notes work **without** the control‑key modifier:
+
+| Note | Action                                                                                       |
+|------|----------------------------------------------------------------------------------------------|
+| 1    | Toggle channel 0 state (IDLE→RECORD→LOOPING→PAUSED→LOOPING…).                               |
+| 60   | Add a dynamic channel (same as `control+60`).                                                |
+| 61   | Remove the highest‑numbered active channel (same as `control+61`).                           |
+
+## Example Usage
+
+1. **Record a loop on channel 0 (using direct note 1)**  
+   - Send note‑on, note 1, velocity 127 → channel 0 enters RECORD.  
+   - Play some audio into `looper:input`.  
+   - Send note‑on, note 1, velocity 127 again → channel 0 enters LOOPING.  
+   - The recorded audio repeats indefinitely.
+
+2. **Use the control‑key to toggle channel 0**  
+   - Send `note‑on, note 64` (control key).  
+   - Then send `note‑on, note 62` → toggles channel 0 (IDLE→RECORD).  
+   - Send `note‑on, note 64` again, then `note‑on, note 62` again → RECORD→LOOPING.
+
+3. **Add a new channel and bind it**  
+   - Send `note‑on, note 64` + `note‑on, note 60` → creates channel 1.  
+   - Send `note‑on, note 64` + `note‑on, note 1` → binds channel 1.  
+   - Now `control+62` toggles channel 1 instead of channel 0.  
+   - Record audio on channel 1 by sending `control+62` twice.
+
+4. **Remove a dynamic channel**  
+   - Send `note‑on, note 64` + `note‑on, note 61` → removes the highest‑numbered active channel (e.g., channel 1).
+
+## Notes
+
+- The looper must be connected to a running JACK server.  
+- Channel buffers hold up to 5 seconds of audio at 48 kHz.  
+- After removal, the channel’s audio ports are unregistered on the next main‑loop cycle (deferred to avoid race conditions).  
+- The bind index is stored as an integer (0–15); values outside 0–15 are ignored (the note is processed as a command rather than a bind).

makefile

@@ -20,3 +20,10 @@ test: integration
 .PHONY: clean integration test
 clean:
 	rm -f looper integration_test src/*.o
+
+check:
+	cppcheck --enable=all --error-exitcode=1 src/*.c
+
+# Optional: Format code using clang-format
+format:
+	clang-format -i src/*.c

src/channel.c

@@ -19,11 +19,11 @@ void channel_add(jack_client_t *client, int idx)
     if (!channels[idx].audio_in || !channels[idx].audio_out) {
         fprintf(stderr, "Failed to register ports for channel %d\n", next_channel_id);
         /* Do NOT mark channel active – process loop will skip it */
-        channels[idx].active = 0;
+        atomic_store(&channels[idx].active, 0);
         return;
     }
 
-    channels[idx].active = 1;
+    atomic_store(&channels[idx].active, 1);
     atomic_store(&channels[idx].state, STATE_IDLE);
     channels[idx].prev_state = -1;
     channels[idx].loop_count = 0;
@@ -36,8 +36,7 @@ void channel_add(jack_client_t *client, int idx)
 
 void channel_remove(jack_client_t *client, int idx)
 {
-    jack_port_unregister(client, channels[idx].audio_in);
+    (void)client;
-    jack_port_unregister(client, channels[idx].audio_out);
+    atomic_store(&channels[idx].active, 0);
-    channels[idx].active = 0;
     channel_count--;
 }

src/channel.h

@@ -21,7 +21,7 @@ struct channel_t {
     int           loop_count;
     int           record_pos;
     int           playback_pos;
-    int           active;
+    atomic_int    active;
     jack_port_t  *audio_in;
     jack_port_t  *audio_out;
 };

src/looper.c

@@ -18,6 +18,10 @@ atomic_int  cmd_remove = 0;
 jack_port_t *midi_control_port = NULL;
 jack_port_t *midi_clock_port = NULL;
 atomic_int  control_key_active = 0;
+atomic_int  bind_channel = 0;
+
+/* Deferred removal index (1 second grace) */
+static int pending_unregister_idx = -1;
 
 /* ----------------------------------------------------------------
  * process callback
@@ -26,14 +30,16 @@ int process_callback(jack_nframes_t nframes, void *arg)
 {
     (void)arg;
 
+    if (midi_control_port) {
         void *midi_ctrl_buf = jack_port_get_buffer(midi_control_port, nframes);
         if (midi_ctrl_buf) {
             midi_handle_events(midi_ctrl_buf, nframes);
         }
+    }
 
     /* process each active channel */
     for (int c = 0; c < MAX_CHANNELS; c++) {
-        if (!channels[c].active) continue;
+        if (!atomic_load(&channels[c].active)) continue;
 
         /* Guard against NULL ports (e.g. if port registration failed) */
         if (!channels[c].audio_in || !channels[c].audio_out) {
@@ -108,6 +114,7 @@ int process_callback(jack_nframes_t nframes, void *arg)
     }
 
     /* MIDI clock events – affect channel 0 only */
+    if (midi_clock_port) {
         void *midi_clock_buf = jack_port_get_buffer(midi_clock_port, nframes);
         if (midi_clock_buf) {
             jack_nframes_t n_clock_events = jack_midi_get_event_count(midi_clock_buf);
@@ -136,6 +143,7 @@ int process_callback(jack_nframes_t nframes, void *arg)
                 }
             }
         }
+    }
 
     return 0;
 }
@@ -194,6 +202,18 @@ int looper_init(jack_client_t *client)
  * ---------------------------------------------------------------- */
 void looper_process_commands(jack_client_t *client)
 {
+    /* Unregister any ports that were marked for deferred removal.
+       By now the real‑time thread has had at least one full cycle
+       to see the `active = 0` store. */
+    if (pending_unregister_idx != -1) {
+        int idx = pending_unregister_idx;
+        if (channels[idx].audio_in)
+            jack_port_unregister(client, channels[idx].audio_in);
+        if (channels[idx].audio_out)
+            jack_port_unregister(client, channels[idx].audio_out);
+        pending_unregister_idx = -1;
+    }
+
     if (atomic_exchange(&cmd_add, 0)) {
         int idx;
         for (idx = 0; idx < MAX_CHANNELS; idx++)
@@ -208,7 +228,9 @@ void looper_process_commands(jack_client_t *client)
         for (int idx = 1; idx < MAX_CHANNELS; idx++)
             if (channels[idx].active) remove_idx = idx;
         if (remove_idx != -1) {
+            /* Mark inactive now; ports will be unregistered next round */
             channel_remove(client, remove_idx);
+            pending_unregister_idx = remove_idx;
         }
     }
 }

src/midi.c

@@ -7,6 +7,7 @@
 extern atomic_int control_key_active;
 extern atomic_int cmd_add;
 extern atomic_int cmd_remove;
+extern atomic_int bind_channel;
 
 void midi_handle_events(void *port_buffer, jack_nframes_t nframes)
 {
@@ -30,31 +31,41 @@ void midi_handle_events(void *port_buffer, jack_nframes_t nframes)
                 int ck = atomic_load(&control_key_active);
                 if (ck) {
                     atomic_store(&control_key_active, 0);
+                    if (note < 16) {
+                        atomic_store(&bind_channel, note);
+                    } else {
                         switch (note) {
                         case 60: atomic_store(&cmd_add, 1); break;
                         case 61: atomic_store(&cmd_remove, 1); break;
-                    case 62: /* trigger looper – channel 0 */
+                        case 62: /* trigger looper – channel via bind_channel */
                             {
-                            int cur0 = atomic_load(&channels[0].state);
+                                int bch = atomic_load(&bind_channel);
-                            switch (cur0) {
+                                if (bch >= 0 && bch < MAX_CHANNELS) {
+                                    int cur = atomic_load(&channels[bch].state);
+                                    switch (cur) {
                                     case STATE_IDLE:
-                                atomic_store(&channels[0].state, STATE_RECORD);
+                                        atomic_store(&channels[bch].state, STATE_RECORD);
                                         break;
                                     case STATE_RECORD:
-                                atomic_store(&channels[0].state, STATE_LOOPING);
+                                        atomic_store(&channels[bch].state, STATE_LOOPING);
                                         break;
                                     case STATE_LOOPING:
-                                atomic_store(&channels[0].state, STATE_PAUSED);
+                                        atomic_store(&channels[bch].state, STATE_PAUSED);
                                         break;
                                     case STATE_PAUSED:
-                                atomic_store(&channels[0].state, STATE_LOOPING);
+                                        atomic_store(&channels[bch].state, STATE_LOOPING);
                                         break;
                                     }
                                 }
+                            }
+                            break;
+                        case 63: /* unbind – reset bind to channel 0 */
+                            atomic_store(&bind_channel, 0);
                             break;
                         default:
                             break;
                         }
+                    }
                 } else {
                     /* direct mapping */
                     switch (note) {

tests/integration.c

@@ -34,6 +34,7 @@ static unsigned char midi_inject_velocity = 0;
 
 static int midi_inject_process(jack_nframes_t nframes, void *arg) {
     (void)arg;
+    if (!midi_inject_port) return 0;
     void *port_buf = jack_port_get_buffer(midi_inject_port, nframes);
     if (!port_buf) return 0;
     jack_midi_clear_buffer(port_buf);
@@ -414,6 +415,418 @@ static int test_multiple_channels(void) {
     return 0;
 }
 
+/* test control‑key modifier (note 64 + note 62) */
+static int test_control_key_modifier(void) {
+    printf("Test: control‑key modifier triggers state transition via note 62\n");
+    pid_t pid = start_looper();
+    if (pid < 0) return 1;
+    jack_client_t *client;
+    jack_status_t status;
+    client = jack_client_open("test_ctrl_key", JackNoStartServer, &status);
+    if (!client) {
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  SKIP: no JACK\n");
+        return 1;
+    }
+    /* connect same as in test_looper_looping but no beep generation */
+    jack_port_t *audio_out = jack_port_register(client, "out",
+                           JACK_DEFAULT_AUDIO_TYPE,
+                           JackPortIsOutput, 0);
+    jack_port_t *audio_in = jack_port_register(client, "in",
+                           JACK_DEFAULT_AUDIO_TYPE,
+                           JackPortIsInput, 0);
+    if (!audio_out || !audio_in) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        return 1;
+    }
+    usleep(200000);
+    char my_out[64], my_in[64];
+    snprintf(my_out, sizeof(my_out), "test_ctrl_key:out");
+    snprintf(my_in,  sizeof(my_in),  "test_ctrl_key:in");
+    if (jack_connect(client, my_out, "looper:input") ||
+        jack_connect(client, "looper:output", my_in)) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        return 1;
+    }
+    /* First send note 64 (control key) */
+    if (send_jack_note_on("looper:control", 64, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: send note 64 failed\n");
+        return 1;
+    }
+    usleep(200000);
+    /* Now send note 62 (toggle channel 0) */
+    if (send_jack_note_on("looper:control", 62, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: send note 62 failed\n");
+        return 1;
+    }
+    /* Wait for looper to enter RECORD and detect audio */
+    int sr = jack_get_sample_rate(client);
+    continuous_sine = 0;
+    beep_remaining = (int)(0.1f * sr);   /* 0.1 second beep */
+    bursts = 0;
+    prev_above = 0;
+    passthrough_output_port = audio_out;
+    passthrough_input_port = audio_in;
+    passthrough_phase = 0.0f;
+    passthrough_freq = 440.0f;
+    passthrough_sample_rate = sr;
+    passthrough_total_samples = 0;
+    passthrough_sum_sq = 0.0;
+    passthrough_done = 0;
+    jack_set_process_callback(client, passthrough_process, NULL);
+    if (jack_activate(client)) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        return 1;
+    }
+    usleep(200000);   /* allow beep */
+    /* send note 62 again under control key to move RECORD->LOOPING */
+    if (send_jack_note_on("looper:control", 64, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: control key re‑send\n");
+        return 1;
+    }
+    usleep(200000);
+    if (send_jack_note_on("looper:control", 62, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: send note 62 for loop\n");
+        return 1;
+    }
+    usleep(2000000);   /* wait for a few loops */
+    jack_deactivate(client);
+    jack_client_close(client);
+    kill(pid, SIGTERM);
+    waitpid(pid, NULL, 0);
+    int got_bursts = bursts;
+    printf("  detected bursts: %d\n", got_bursts);
+    if (got_bursts < 3) {
+        fprintf(stderr, "  FAIL: expected ≥3 bursts, got %d\n", got_bursts);
+        return 1;
+    }
+    printf("  PASS (control‑key modifier works)\n");
+    return 0;
+}
+
+/* test bind channel */
+static int test_bind_channel(void) {
+    printf("Test: control‑key bind channel (note 0) and toggle\n");
+    pid_t pid = start_looper();
+    if (pid < 0) return 1;
+    jack_client_t *client;
+    jack_status_t status;
+    client = jack_client_open("test_bind", JackNoStartServer, &status);
+    if (!client) {
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  SKIP: no JACK\n");
+        return 1;
+    }
+    jack_port_t *audio_out = jack_port_register(client, "out",
+                           JACK_DEFAULT_AUDIO_TYPE,
+                           JackPortIsOutput, 0);
+    jack_port_t *audio_in = jack_port_register(client, "in",
+                           JACK_DEFAULT_AUDIO_TYPE,
+                           JackPortIsInput, 0);
+    if (!audio_out || !audio_in) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        return 1;
+    }
+    usleep(200000);
+    char my_out[64], my_in[64];
+    snprintf(my_out, sizeof(my_out), "test_bind:out");
+    snprintf(my_in,  sizeof(my_in),  "test_bind:in");
+    if (jack_connect(client, my_out, "looper:input") ||
+        jack_connect(client, "looper:output", my_in)) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        return 1;
+    }
+    /* Send control key + note 0 to bind to channel 0 */
+    if (send_jack_note_on("looper:control", 64, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: send control key failed\n");
+        return 1;
+    }
+    usleep(200000);
+    if (send_jack_note_on("looper:control", 0, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: send bind note 0 failed\n");
+        return 1;
+    }
+    usleep(200000);
+    /* Now toggle using control+note62 – should toggle channel 0 */
+    if (send_jack_note_on("looper:control", 64, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: send control key again failed\n");
+        return 1;
+    }
+    usleep(200000);
+    if (send_jack_note_on("looper:control", 62, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: send toggle note 62 failed\n");
+        return 1;
+    }
+    /* Wait and detect bursts as before */
+    int sr = jack_get_sample_rate(client);
+    continuous_sine = 0;
+    beep_remaining = (int)(0.1f * sr);
+    bursts = 0;
+    prev_above = 0;
+    passthrough_output_port = audio_out;
+    passthrough_input_port = audio_in;
+    passthrough_phase = 0.0f;
+    passthrough_freq = 440.0f;
+    passthrough_sample_rate = sr;
+    passthrough_total_samples = 0;
+    passthrough_sum_sq = 0.0;
+    passthrough_done = 0;
+    jack_set_process_callback(client, passthrough_process, NULL);
+    if (jack_activate(client)) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        return 1;
+    }
+    usleep(200000); /* allow beep */
+    /* send control+note62 again to move RECORD->LOOPING */
+    if (send_jack_note_on("looper:control", 64, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: control key for loop\n");
+        return 1;
+    }
+    usleep(200000);
+    if (send_jack_note_on("looper:control", 62, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: toggle for loop\n");
+        return 1;
+    }
+    usleep(2000000);
+    jack_deactivate(client);
+    jack_client_close(client);
+    kill(pid, SIGTERM);
+    waitpid(pid, NULL, 0);
+    int got_bursts = bursts;
+    printf("  detected bursts: %d\n", got_bursts);
+    if (got_bursts < 3) {
+        fprintf(stderr, "  FAIL: expected >=3 bursts, got %d\n", got_bursts);
+        return 1;
+    }
+    printf("  PASS (bind and toggle)\n");
+    return 0;
+}
+
+/* test unbind */
+static int test_bind_unbind(void) {
+    printf("Test: bind to channel 5, unbind, then toggle default (channel 0)\n");
+    pid_t pid = start_looper();
+    if (pid < 0) return 1;
+    jack_client_t *client;
+    jack_status_t status;
+    client = jack_client_open("test_unbind", JackNoStartServer, &status);
+    if (!client) {
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  SKIP: no JACK\n");
+        return 1;
+    }
+    jack_port_t *audio_out = jack_port_register(client, "out",
+                           JACK_DEFAULT_AUDIO_TYPE,
+                           JackPortIsOutput, 0);
+    jack_port_t *audio_in = jack_port_register(client, "in",
+                           JACK_DEFAULT_AUDIO_TYPE,
+                           JackPortIsInput, 0);
+    if (!audio_out || !audio_in) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        return 1;
+    }
+    usleep(200000);
+    char my_out[64], my_in[64];
+    snprintf(my_out, sizeof(my_out), "test_unbind:out");
+    snprintf(my_in,  sizeof(my_in),  "test_unbind:in");
+    if (jack_connect(client, my_out, "looper:input") ||
+        jack_connect(client, "looper:output", my_in)) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        return 1;
+    }
+    /* Bind to channel 5 */
+    if (send_jack_note_on("looper:control", 64, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: send control key failed\n");
+        return 1;
+    }
+    usleep(200000);
+    if (send_jack_note_on("looper:control", 5, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: bind to 5 failed\n");
+        return 1;
+    }
+    usleep(200000);
+    /* Unbind (reset to 0) */
+    if (send_jack_note_on("looper:control", 64, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: control key for unbind\n");
+        return 1;
+    }
+    usleep(200000);
+    if (send_jack_note_on("looper:control", 63, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: send unbind note 63 failed\n");
+        return 1;
+    }
+    usleep(200000);
+    /* Now toggle with control+62 – should affect channel 0 */
+    if (send_jack_note_on("looper:control", 64, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: control key for toggle\n");
+        return 1;
+    }
+    usleep(200000);
+    if (send_jack_note_on("looper:control", 62, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: toggle note 62\n");
+        return 1;
+    }
+    /* Wait for beep and loop */
+    int sr = jack_get_sample_rate(client);
+    continuous_sine = 0;
+    beep_remaining = (int)(0.1f * sr);
+    bursts = 0;
+    prev_above = 0;
+    passthrough_output_port = audio_out;
+    passthrough_input_port = audio_in;
+    passthrough_phase = 0.0f;
+    passthrough_freq = 440.0f;
+    passthrough_sample_rate = sr;
+    passthrough_total_samples = 0;
+    passthrough_sum_sq = 0.0;
+    passthrough_done = 0;
+    jack_set_process_callback(client, passthrough_process, NULL);
+    if (jack_activate(client)) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        return 1;
+    }
+    usleep(200000); /* allow beep */
+    /* second control+62 -> loop */
+    if (send_jack_note_on("looper:control", 64, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: control key for loop\n");
+        return 1;
+    }
+    usleep(200000);
+    if (send_jack_note_on("looper:control", 62, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: toggle for loop\n");
+        return 1;
+    }
+    usleep(2000000);
+    jack_deactivate(client);
+    jack_client_close(client);
+    kill(pid, SIGTERM);
+    waitpid(pid, NULL, 0);
+    int got_bursts = bursts;
+    printf("  detected bursts: %d\n", got_bursts);
+    if (got_bursts < 3) {
+        fprintf(stderr, "  FAIL: expected >=3 bursts, got %d\n", got_bursts);
+        return 1;
+    }
+    printf("  PASS (unbind works, toggle channel 0)\n");
+    return 0;
+}
+
+/* test remove channel */
+static int test_remove_channel(void) {
+    printf("Test: dynamic channel removal via MIDI command\n");
+    pid_t pid = start_looper();
+    if (pid < 0) return 1;
+    jack_client_t *client;
+    jack_status_t status;
+    client = jack_client_open("test_remove", JackNoStartServer, &status);
+    if (!client) {
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  SKIP: no JACK\n");
+        return 1;
+    }
+    /* add channel */
+    if (send_jack_note_on("looper:control", 60, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: send note 60 failed\n");
+        return 1;
+    }
+    usleep(1500000);
+    /* verify channel1_input exists */
+    const char **ports = jack_get_ports(client, NULL, JACK_DEFAULT_AUDIO_TYPE, 0);
+    int found = 0;
+    if (ports) {
+        for (int i = 0; ports[i]; i++) {
+            if (strstr(ports[i], "looper:channel1_input")) {
+                found = 1;
+                break;
+            }
+        }
+        jack_free(ports);
+    }
+    if (!found) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: channel1_input not created\n");
+        return 1;
+    }
+    printf("  channel1_input created\n");
+    /* remove channel */
+    if (send_jack_note_on("looper:control", 61, 127) != 0) {
+        jack_client_close(client);
+        kill(pid, SIGTERM); waitpid(pid, NULL, 0);
+        fprintf(stderr, "  FAIL: send note 61 failed\n");
+        return 1;
+    }
+    usleep(1500000);
+    /* verify channel1_input has disappeared */
+    ports = jack_get_ports(client, NULL, JACK_DEFAULT_AUDIO_TYPE, 0);
+    int still_found = 0;
+    if (ports) {
+        for (int i = 0; ports[i]; i++) {
+            if (strstr(ports[i], "looper:channel1_input")) {
+                still_found = 1;
+                break;
+            }
+        }
+        jack_free(ports);
+    }
+    jack_client_close(client);
+    kill(pid, SIGTERM);
+    waitpid(pid, NULL, 0);
+    if (still_found) {
+        fprintf(stderr, "  FAIL: channel1_input not removed after remove command\n");
+        return 1;
+    }
+    printf("  PASS (channel removed)\n");
+    return 0;
+}
+
 
 int main(void) {
     /* 1. binary must exist */
@@ -427,18 +840,48 @@ int main(void) {
     /* 3. Audio pass‑through test – must work for basic connectivity */
     test_audio_pass_through();
 
+    int failures = 0;
+
     /* 4. Test that looping feature is now implemented */
     if (test_looper_looping() != 0) {
         fprintf(stderr, "  FAILED\n");
-        return 1;
+        failures++;
     }
 
     /* 5. Test multiple dynamic channels */
     if (test_multiple_channels() != 0) {
         fprintf(stderr, "  FAILED\n");
-        return 1;
+        failures++;
     }
 
+    /* 6. Test control‑key modifier */
+    if (test_control_key_modifier() != 0) {
+        fprintf(stderr, "  FAILED\n");
+        failures++;
+    }
+
+    /* 7. Test bind channel */
+    if (test_bind_channel() != 0) {
+        fprintf(stderr, "  FAILED\n");
+        failures++;
+    }
+
+    /* 8. Test unbind */
+    if (test_bind_unbind() != 0) {
+        fprintf(stderr, "  FAILED\n");
+        failures++;
+    }
+
+    /* 9. Test channel removal */
+    if (test_remove_channel() != 0) {
+        fprintf(stderr, "  FAILED\n");
+        failures++;
+    }
+
+    if (failures > 0) {
+        fprintf(stderr, "%d test(s) FAILED\n", failures);
+        return 1;
+    }
     printf("All tests completed successfully.\n");
     return 0;
 }