fix: ensure stable recording ID reuse in non-persistent runtime and update tests

Author: djradon

.kato/test-tmp/in-chat-record-commands/new.md

@@ -5,6 +5,6 @@ desc: ''
 created: 1771754400000
 updated: 1771754400000
 sessionId: session-1
-recordingIds: [2da347e7-cdd0-4fa9-ad18-aaa823dd9aa6]
+recordingIds: [42a0bf5e-142b-41e2-8a1b-91cace88400b]
 conversationEventKinds: [message.user]
 ---

apps/daemon/src/orchestrator/daemon_runtime.ts

@@ -1368,7 +1368,21 @@ async function applyControlCommandsForEvent(
           provider,
           sessionId,
         );
-        if (active && active.outputPath === resolvedDestination) {
+        const activeOnResolvedDestination = active &&
+          active.outputPath === resolvedDestination;
+        const existingRecordingId = sessionEventState.destinationRecordingIds.get(
+          resolvedDestination,
+        );
+        const recordingIdToUse = existingRecordingId ??
+          (activeOnResolvedDestination ? active.recordingId : undefined) ??
+          crypto.randomUUID();
+        if (!existingRecordingId) {
+          sessionEventState.destinationRecordingIds.set(
+            resolvedDestination,
+            recordingIdToUse,
+          );
+        }
+        if (activeOnResolvedDestination) {
           commandNoop = true;
         } else {
           const seedEvents = buildCommandSeedEvents(
@@ -1382,6 +1396,7 @@ async function applyControlCommandsForEvent(
             targetPath: resolvedDestination,
             seedEvents,
             title: recordingTitle,
+            recordingId: recordingIdToUse,
           });
         }
         sessionEventState.primaryRecordingDestination = resolvedDestination;

dev-docs/notes/conv.2026.2026-02-27-inchat-command-redesign.md

@@ -742,4 +742,103 @@ So the clean status split is:
 
 I’d mark the redesign task complete, with one brief note in it:
 - relative explicit path support is intentionally deferred to the per-workspace daemon task
-- `primaryRecordingDestination` remains the session pointer; `defaultOutputPath` will be a config default, not a rename of that field
+- `primaryRecordingDestination` remains the session pointer; `defaultOutputPath` will be a config default, not a rename of that field
+
+# User_2026-02-27_2154_41
+
+coderabbit feedback:
+
+In `@apps/daemon/src/orchestrator/daemon_runtime.ts`:
+- Around line 1321-1347: The ::record branch activates a recording without
+reusing an existing recordingId, which can rotate IDs for the same destination
+and break stability; look up sessionEventState.destinationRecordingIds for the
+resolved destination (the same key used by ::init/::capture), and when calling
+recordingPipeline.activateRecording pass the existing recordingId (or preserve
+it in the activateRecording payload) instead of always creating a new one;
+update the activation call in the block using resolvedDestination,
+recordingPipeline.getActiveRecording, and recordingPipeline.activateRecording to
+include/reuse the recordingId from
+sessionEventState.destinationRecordingIds[resolvedDestination] when present.
+
+**Planning code inspection and fix**
+
+# gpt-5.3-codex_2026-02-27_2154_48
+
+I’m checking that `::record` path in the non-persistent runtime branch against the current code, then I’ll patch it and add a regression test if the feedback is valid.
+
+**Exploring record branch code**
+
+**Planning stable recording ID reuse**
+**Designing stable recording ID handling**
+**Augmenting existing test for ID reuse**
+**Implementing robust recordingId handling and test adjustments**
+
+# gpt-5.3-codex_2026-02-27_2155_31
+
+I confirmed the feedback is valid: the non-persistent `::record` branch was not passing a stable `recordingId`. I’m patching that branch now and tightening the existing non-persistent `::init + ::record` test so it proves the activated ID matches the init-prepared file.
+
+**Adding activated recording ID tracking**
+
+**Running targeted tests**
+
+# gpt-5.3-codex_2026-02-27_2155_53
+
+I patched the runtime branch and added a regression assertion in the existing non-persistent `::init + ::record` test to prove the activated `recordingId` matches the init-prepared file. I’m running the targeted tests now.
+
+**Running full lint and tests**
+
+# gpt-5.3-codex_2026-02-27_2156_06
+
+The targeted regression passes. I’m running the full quality gates now because this touches core runtime behavior.
+
+# gpt-5.3-codex_2026-02-27_2156_09
+
+`lint` is done; `check` and the full test suite are still running. Once they complete I’ll give you the exact change summary and whether this feedback item is fully cleared.
+
+**Fixing test file cleanup to ensure fresh state**
+
+# gpt-5.3-codex_2026-02-27_2156_22
+
+The full suite exposed a test hygiene issue, not a logic regression: that non-persistent test reuses a fixed `.kato/test-tmp/.../new.md` path, so stale files can make the new frontmatter assertion nondeterministic. I’m making that test clean its temp directory before it runs.
+
+**Adding async directory cleanup**
+
+**Rerunning full tests and checks**
+
+# gpt-5.3-codex_2026-02-27_2156_37
+
+I fixed the flaky temp-file reuse in the regression test. `check` and the full test suite are running again; once they finish, this feedback item should be closed cleanly.
+
+**Planning detailed git diff inspection**
+
+**Extending code view for ID trace**
+
+**Summarizing fix and validation**
+
+# gpt-5.3-codex_2026-02-27_2157_05
+
+The feedback was valid, and it’s fixed.
+
+What changed:
+- The non-persistent `::record` branch now reuses the stable per-destination `recordingId` from `sessionEventState.destinationRecordingIds`, falls back to the active recording’s ID on same-target no-op, and only generates a new ID if neither exists.
+- That reused ID is now passed into `recordingPipeline.activateRecording(...)`.
+
+Code:
+- Reuse/seed stable ID: [daemon_runtime.ts:1371](/home/djradon/hub/spectacular-voyage/kato/apps/daemon/src/orchestrator/daemon_runtime.ts:1371)
+- Pass reused ID into activation: [daemon_runtime.ts:1393](/home/djradon/hub/spectacular-voyage/kato/apps/daemon/src/orchestrator/daemon_runtime.ts:1393)
+
+Regression coverage:
+- Tightened the existing non-persistent `::init + ::record` test so it now verifies the activated `recordingId` is non-empty and matches the ID written into the init-prepared file’s frontmatter.
+- Also made that test clear its temp directory first so it can’t be polluted by stale files from prior runs.
+
+Test updates:
+- Temp-dir cleanup: [daemon-runtime_test.ts:2957](/home/djradon/hub/spectacular-voyage/kato/tests/daemon-runtime_test.ts:2957)
+- Capture activation `recordingId`: [daemon-runtime_test.ts:3071](/home/djradon/hub/spectacular-voyage/kato/tests/daemon-runtime_test.ts:3071)
+- Assert file contains the same ID: [daemon-runtime_test.ts:3143](/home/djradon/hub/spectacular-voyage/kato/tests/daemon-runtime_test.ts:3143)
+
+Validation:
+- `deno task lint` passed
+- `deno task check` passed
+- `deno task test` passed (`279 passed, 0 failed`)
+
+So this CodeRabbit item is cleared.

dev-docs/notes/dev.todo.md

@@ -2,7 +2,7 @@
 id: mhthe39ktidk76iy77kcxbn
 title: Todo
 desc: ''
-updated: 1772257357673
+updated: 1772258142220
 created: 1771812869620
 ---
 
@@ -37,11 +37,8 @@ created: 1771812869620
 
 - [ ] Add `kato config validate` command for preflight runtime config checks.
 - [ ] Improve startup error UX for config/schema failures with actionable remediation hints.
-- [ ] Add workspace command surface: `kato workspace register|list|unregister|discover`.
 - [ ] Add workspace pre-persist verification and runtime re-verification status
       (`valid|invalid|unverified`) with explicit error reasons.
-- [ ] Add workspace-aware relative path resolution (session workspace identity)
-      so in-chat relative targets do not depend on daemon cwd.
 
 ## Config And Feature-Flag Evolution
 

tests/daemon-runtime_test.ts

@@ -2954,6 +2954,8 @@ Deno.test("runDaemonRuntimeLoop applies in-chat ::record commands from newly ing
   );
   const oldPath = join(inChatCommandDir, "old.md");
   const newPath = join(inChatCommandDir, "new.md");
+  await removeDirIfPresent(inChatCommandDir);
+  await Deno.mkdir(inChatCommandDir, { recursive: true });
 
   let pollCount = 0;
   const ingestionRunner: ProviderIngestionRunner = {
@@ -3067,15 +3069,18 @@ Deno.test("runDaemonRuntimeLoop applies in-chat ::record commands from newly ing
   };
 
   const activatedTargets: string[] = [];
+  const activatedRecordingIds: string[] = [];
   const appendedMessageIds: string[] = [];
   let activeRecording = false;
   const recordingPipeline: RecordingPipelineLike = {
     activateRecording(input) {
       activeRecording = true;
       activatedTargets.push(input.targetPath);
+      const recordingId = input.recordingId ?? "rec-1";
+      activatedRecordingIds.push(recordingId);
       const nowIso = "2026-02-22T10:00:01.000Z";
       return Promise.resolve({
-        recordingId: "rec-1",
+        recordingId,
         provider: input.provider,
         sessionId: input.sessionId,
         outputPath: input.targetPath,
@@ -3136,9 +3141,13 @@ Deno.test("runDaemonRuntimeLoop applies in-chat ::record commands from newly ing
   });
 
   assertEquals(activatedTargets, [newPath]);
+  assertEquals(activatedRecordingIds.length, 1);
+  assert(activatedRecordingIds[0].length > 0);
   assertEquals(appendedMessageIds, ["m2", "m3"]);
   const newDestinationStat = await Deno.stat(newPath);
   assert(newDestinationStat.isFile);
+  const newDestinationContent = await Deno.readTextFile(newPath);
+  assert(newDestinationContent.includes(activatedRecordingIds[0]));
 });
 
 Deno.test("runDaemonRuntimeLoop applies in-chat ::capture then activates recording on same path", async () => {