groove-dev 0.27.102 → 0.27.103

package/moe-training/test/client/parsers/claude-code.test.js

@@ -3,6 +3,27 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 import { ClaudeCodeParser } from '../../../client/parsers/claude-code.js';
+import { PIIScrubber } from '../../../client/scrubber.js';
+import { OBSERVATION_TOKEN_LIMIT } from '../../../shared/constants.js';
+
+function makeToolUseEvent(id, name, input) {
+  return {
+    type: 'assistant',
+    message: {
+      content: [{ type: 'tool_use', id, name, input }],
+      usage: {},
+    },
+  };
+}
+
+function makeUserToolResult(toolUseId, content, isError = false) {
+  return {
+    type: 'user',
+    message: {
+      content: [{ type: 'tool_result', tool_use_id: toolUseId, content, is_error: isError }],
+    },
+  };
+}
 
 describe('ClaudeCodeParser', () => {
   it('parses assistant message as thought', () => {
@@ -35,44 +56,6 @@ describe('ClaudeCodeParser', () => {
     assert.deepEqual(result.arguments, { file_path: '/test.js' });
   });
 
-  it('parses tool_result as observation', () => {
-    const parser = new ClaudeCodeParser();
-    // First register a tool use
-    parser.parseEvent({
-      type: 'assistant',
-      message: {
-        content: [{ type: 'tool_use', id: 'tu_2', name: 'Read', input: {} }],
-        usage: {},
-      },
-    });
-    // Then parse result
-    const event = {
-      type: 'assistant',
-      message: {
-        content: [{ type: 'tool_result', tool_use_id: 'tu_2', content: 'file contents here', is_error: false }],
-        usage: {},
-      },
-    };
-    const result = parser.parseEvent(event);
-    assert.equal(result.type, 'observation');
-    assert.equal(result.content, 'file contents here');
-    assert.equal(result.is_error, false);
-  });
-
-  it('parses error tool_result as error', () => {
-    const parser = new ClaudeCodeParser();
-    const event = {
-      type: 'assistant',
-      message: {
-        content: [{ type: 'tool_result', tool_use_id: 'tu_3', content: 'Permission denied', is_error: true }],
-        usage: {},
-      },
-    };
-    const result = parser.parseEvent(event);
-    assert.equal(result.type, 'error');
-    assert.equal(result.is_error, true);
-  });
-
   it('parses result event as resolution', () => {
     const parser = new ClaudeCodeParser();
     const event = { type: 'result', result: 'Task completed successfully', total_tokens_used: 500 };
@@ -116,4 +99,231 @@ describe('ClaudeCodeParser', () => {
     assert.equal(parser.parseEvent({ type: 'system' }), null);
     assert.equal(parser.parseEvent(null), null);
   });
+
+  describe('observation steps from user events', () => {
+    it('emits observation for Bash tool result', () => {
+      const parser = new ClaudeCodeParser();
+      parser.parseEvent(makeToolUseEvent('tu_bash', 'Bash', { command: 'ls -la' }));
+
+      const result = parser.parseEvent(makeUserToolResult('tu_bash', 'file1.js\nfile2.js'));
+      assert.equal(result.type, 'observation');
+      assert.equal(result.content, 'file1.js\nfile2.js');
+      assert.equal(result.is_error, false);
+      assert.equal(result.tool, 'Bash');
+      assert.equal(result.truncated, false);
+      assert.equal(result.original_token_count, Math.ceil('file1.js\nfile2.js'.length / 4));
+    });
+
+    it('emits observation for Read tool result', () => {
+      const parser = new ClaudeCodeParser();
+      parser.parseEvent(makeToolUseEvent('tu_read', 'Read', { file_path: '/src/index.js' }));
+
+      const result = parser.parseEvent(makeUserToolResult('tu_read', 'const x = 1;'));
+      assert.equal(result.type, 'observation');
+      assert.equal(result.content, 'const x = 1;');
+      assert.equal(result.tool, 'Read');
+    });
+
+    it('emits observation for Edit tool result', () => {
+      const parser = new ClaudeCodeParser();
+      parser.parseEvent(makeToolUseEvent('tu_edit', 'Edit', { file_path: '/src/app.js' }));
+
+      const result = parser.parseEvent(makeUserToolResult('tu_edit', 'Edit applied successfully'));
+      assert.equal(result.type, 'observation');
+      assert.equal(result.content, 'Edit applied successfully');
+      assert.equal(result.tool, 'Edit');
+    });
+
+    it('emits error for failed tool result', () => {
+      const parser = new ClaudeCodeParser();
+      parser.parseEvent(makeToolUseEvent('tu_fail', 'Bash', { command: 'cat /nonexistent' }));
+
+      const result = parser.parseEvent(makeUserToolResult('tu_fail', 'cat: /nonexistent: No such file or directory', true));
+      assert.equal(result.type, 'error');
+      assert.equal(result.is_error, true);
+      assert.equal(result.tool, 'Bash');
+      assert.match(result.content, /No such file or directory/);
+    });
+
+    it('handles array content in tool_result blocks', () => {
+      const parser = new ClaudeCodeParser();
+      parser.parseEvent(makeToolUseEvent('tu_arr', 'Grep', { pattern: 'TODO' }));
+
+      const event = {
+        type: 'user',
+        message: {
+          content: [{
+            type: 'tool_result',
+            tool_use_id: 'tu_arr',
+            content: [{ type: 'text', text: 'src/a.js:1:TODO fix' }, { type: 'text', text: 'src/b.js:5:TODO refactor' }],
+            is_error: false,
+          }],
+        },
+      };
+      const result = parser.parseEvent(event);
+      assert.equal(result.type, 'observation');
+      assert.equal(result.content, 'src/a.js:1:TODO fix\nsrc/b.js:5:TODO refactor');
+    });
+
+    it('handles multiple tool_result blocks in one user event', () => {
+      const parser = new ClaudeCodeParser();
+      parser.parseEvent(makeToolUseEvent('tu_m1', 'Read', { file_path: '/a.js' }));
+      parser.parseEvent(makeToolUseEvent('tu_m2', 'Read', { file_path: '/b.js' }));
+
+      const event = {
+        type: 'user',
+        message: {
+          content: [
+            { type: 'tool_result', tool_use_id: 'tu_m1', content: 'content of a', is_error: false },
+            { type: 'tool_result', tool_use_id: 'tu_m2', content: 'content of b', is_error: false },
+          ],
+        },
+      };
+      const results = parser.parseEvent(event);
+      assert.ok(Array.isArray(results));
+      assert.equal(results.length, 2);
+      assert.equal(results[0].type, 'observation');
+      assert.equal(results[0].tool, 'Read');
+      assert.equal(results[1].type, 'observation');
+      assert.equal(results[1].tool, 'Read');
+    });
+
+    it('returns null for user event without tool_result blocks', () => {
+      const parser = new ClaudeCodeParser();
+      const result = parser.parseEvent({
+        type: 'user',
+        message: { content: [{ type: 'text', text: 'user said something' }] },
+      });
+      assert.equal(result, null);
+    });
+
+    it('returns null for user event with non-array content', () => {
+      const parser = new ClaudeCodeParser();
+      assert.equal(parser.parseEvent({ type: 'user', message: { content: 'just text' } }), null);
+      assert.equal(parser.parseEvent({ type: 'user', message: {} }), null);
+    });
+
+    it('cleans up _pendingToolUse after matching result', () => {
+      const parser = new ClaudeCodeParser();
+      parser.parseEvent(makeToolUseEvent('tu_clean', 'Bash', { command: 'echo hi' }));
+      assert.equal(parser._pendingToolUse.size, 1);
+
+      parser.parseEvent(makeUserToolResult('tu_clean', 'hi'));
+      assert.equal(parser._pendingToolUse.size, 0);
+    });
+
+    it('handles unmatched tool_result (no prior tool_use)', () => {
+      const parser = new ClaudeCodeParser();
+      const result = parser.parseEvent(makeUserToolResult('tu_orphan', 'some output'));
+      assert.equal(result.type, 'observation');
+      assert.equal(result.tool, undefined);
+    });
+  });
+
+  describe('observation truncation', () => {
+    it('truncates observation exceeding token limit', () => {
+      const parser = new ClaudeCodeParser();
+      parser.parseEvent(makeToolUseEvent('tu_long', 'Bash', { command: 'cat bigfile' }));
+
+      const charLimit = OBSERVATION_TOKEN_LIMIT * 4;
+      const longContent = 'x'.repeat(charLimit + 1000);
+
+      const result = parser.parseEvent(makeUserToolResult('tu_long', longContent));
+      assert.equal(result.type, 'observation');
+      assert.equal(result.truncated, true);
+      assert.ok(result.original_token_count > OBSERVATION_TOKEN_LIMIT);
+      assert.match(result.content, /\[TRUNCATED/);
+      assert.ok(result.content.length <= charLimit + 100);
+    });
+
+    it('does not truncate short observation content', () => {
+      const parser = new ClaudeCodeParser();
+      parser.parseEvent(makeToolUseEvent('tu_short', 'Bash', { command: 'echo hi' }));
+
+      const shortContent = 'line 1\nline 2\nline 3';
+      const result = parser.parseEvent(makeUserToolResult('tu_short', shortContent));
+      assert.equal(result.content, shortContent);
+      assert.equal(result.truncated, false);
+      assert.equal(result.original_token_count, Math.ceil(shortContent.length / 4));
+    });
+
+    it('does not truncate errors', () => {
+      const parser = new ClaudeCodeParser();
+      parser.parseEvent(makeToolUseEvent('tu_err_long', 'Bash', { command: 'bad' }));
+
+      const longError = 'x'.repeat(20000);
+      const result = parser.parseEvent(makeUserToolResult('tu_err_long', longError, true));
+      assert.equal(result.type, 'error');
+      assert.equal(result.content, longError);
+      assert.equal(result.truncated, undefined);
+    });
+  });
+
+  describe('scrubber integration', () => {
+    it('observation content is scrubber-compatible (string format)', () => {
+      const parser = new ClaudeCodeParser();
+      parser.parseEvent(makeToolUseEvent('tu_scrub', 'Bash', { command: 'env' }));
+
+      const result = parser.parseEvent(makeUserToolResult('tu_scrub', 'API_KEY=sk_test_abc123def456ghi789'));
+      assert.equal(typeof result.content, 'string');
+
+      const scrubber = new PIIScrubber();
+      const scrubbed = scrubber.scrub(result.content);
+      assert.match(scrubbed, /\[API_KEY\]/);
+      assert.ok(!scrubbed.includes('sk_test_abc123def456ghi789'));
+    });
+
+    it('scrubber handles observation with email addresses', () => {
+      const parser = new ClaudeCodeParser();
+      parser.parseEvent(makeToolUseEvent('tu_email', 'Bash', { command: 'git log' }));
+
+      const result = parser.parseEvent(makeUserToolResult('tu_email', 'Author: user@example.com'));
+      const scrubber = new PIIScrubber();
+      const scrubbed = scrubber.scrub(result.content);
+      assert.match(scrubbed, /\[EMAIL\]/);
+    });
+  });
+
+  describe('full ReAct loop', () => {
+    it('produces thought → action → observation → thought sequence', () => {
+      const parser = new ClaudeCodeParser();
+      const steps = [];
+
+      // Thought + action (assistant event with text and tool_use)
+      const assistantEvent = {
+        type: 'assistant',
+        message: {
+          content: [
+            { type: 'text', text: 'Let me check the file' },
+            { type: 'tool_use', id: 'tu_react', name: 'Read', input: { file_path: '/src/app.js' } },
+          ],
+          usage: { input_tokens: 100, output_tokens: 50 },
+        },
+      };
+      const parsed1 = parser.parseEvent(assistantEvent);
+      const events1 = Array.isArray(parsed1) ? parsed1 : [parsed1];
+      steps.push(...events1);
+
+      // Observation (user event with tool_result)
+      const parsed2 = parser.parseEvent(makeUserToolResult('tu_react', 'const app = express();'));
+      const events2 = Array.isArray(parsed2) ? parsed2 : [parsed2];
+      steps.push(...events2);
+
+      // Next thought (assistant event)
+      const parsed3 = parser.parseEvent({
+        type: 'assistant',
+        message: {
+          content: [{ type: 'text', text: 'I see the Express setup, now let me fix it' }],
+          usage: { input_tokens: 200, output_tokens: 60 },
+        },
+      });
+      steps.push(parsed3);
+
+      assert.equal(steps.length, 4);
+      assert.equal(steps[0].type, 'thought');
+      assert.equal(steps[1].type, 'action');
+      assert.equal(steps[2].type, 'observation');
+      assert.equal(steps[3].type, 'thought');
+    });
+  });
 });

package/moe-training/test/client/parsers/codex.test.js

@@ -44,6 +44,8 @@ describe('CodexParser', () => {
     });
     assert.equal(result.type, 'observation');
     assert.equal(result.content, 'file1\nfile2');
+    assert.equal(result.truncated, false);
+    assert.equal(typeof result.original_token_count, 'number');
   });
 
   it('parses item.completed with error exit code as error', () => {

package/moe-training/test/client/parsers/gemini.test.js

@@ -57,6 +57,8 @@ describe('GeminiParser', () => {
     });
     assert.equal(result.type, 'observation');
     assert.equal(result.content, 'Found 3 matches');
+    assert.equal(result.truncated, false);
+    assert.equal(typeof result.original_token_count, 'number');
   });
 
   it('parses error event', () => {

package/moe-training/test/client/trajectory-capture.test.js

@@ -0,0 +1,345 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { TrajectoryCapture } from '../../client/trajectory-capture.js';
+
+function makeTc() {
+  const tc = new TrajectoryCapture({ centralCommandUrl: 'http://localhost:9999' });
+  return tc;
+}
+
+function makeCtx(overrides = {}) {
+  return {
+    sessionId: 'sess_test_1',
+    stepCount: overrides.stepCount ?? 20,
+    totalTokens: overrides.totalTokens ?? 5000,
+    errorsEncountered: overrides.errorsEncountered ?? 0,
+    errorsRecovered: overrides.errorsRecovered ?? 0,
+    coordinationEvents: overrides.coordinationEvents ?? 0,
+    revisionRounds: overrides.revisionRounds ?? 0,
+    allSteps: overrides.allSteps ?? [
+      { step: 1, type: 'thought', content: 'thinking' },
+      { step: 2, type: 'action', tool: 'Bash', content: 'running command' },
+      { step: 3, type: 'observation', content: 'output here' },
+      { step: 4, type: 'thought', content: 'next step' },
+      { step: 5, type: 'action', tool: 'Edit', content: 'editing file' },
+    ],
+    metadata: {
+      session_quality: overrides.quality ?? 80,
+    },
+    builder: {
+      buildSessionClose: (outcome) => ({
+        envelope_id: 'env_test_close',
+        session_id: 'sess_test_1',
+        type: 'SESSION_CLOSE',
+        outcome,
+      }),
+    },
+  };
+}
+
+describe('TrajectoryCapture — quality tier', () => {
+  it('TIER_A: high quality, no errors, no interventions, SUCCESS', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ quality: 80, errorsEncountered: 0 });
+    const result = tc._computeQualityTier(ctx, 'SUCCESS', 0);
+    assert.equal(result.tier, 'TIER_A');
+    assert.equal(result.reason, 'high_quality_no_errors');
+  });
+
+  it('TIER_A requires quality >= 70', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ quality: 69, errorsEncountered: 0 });
+    const result = tc._computeQualityTier(ctx, 'SUCCESS', 0);
+    assert.notEqual(result.tier, 'TIER_A');
+  });
+
+  it('TIER_A requires zero errors', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ quality: 80, errorsEncountered: 1 });
+    const result = tc._computeQualityTier(ctx, 'SUCCESS', 0);
+    assert.notEqual(result.tier, 'TIER_A');
+  });
+
+  it('TIER_A requires zero user interventions', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ quality: 80, errorsEncountered: 0 });
+    const result = tc._computeQualityTier(ctx, 'SUCCESS', 1);
+    assert.notEqual(result.tier, 'TIER_A');
+  });
+
+  it('TIER_A requires SUCCESS status', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ quality: 80, errorsEncountered: 0 });
+    const result = tc._computeQualityTier(ctx, 'CRASH', 0);
+    assert.notEqual(result.tier, 'TIER_A');
+  });
+
+  it('TIER_B: moderate quality >= 50 with SUCCESS', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ quality: 55, errorsEncountered: 0 });
+    const result = tc._computeQualityTier(ctx, 'SUCCESS', 0);
+    assert.equal(result.tier, 'TIER_B');
+    assert.equal(result.reason, 'moderate_quality');
+  });
+
+  it('TIER_C: non-SUCCESS status overrides quality', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ quality: 55, errorsEncountered: 0 });
+    const result = tc._computeQualityTier(ctx, 'CRASH', 0);
+    assert.equal(result.tier, 'TIER_C');
+    assert.equal(result.reason, 'non_success_status');
+  });
+
+  it('TIER_B: errors fully recovered', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ quality: 40, errorsEncountered: 2, errorsRecovered: 2 });
+    const result = tc._computeQualityTier(ctx, 'SUCCESS', 0);
+    assert.equal(result.tier, 'TIER_B');
+    assert.equal(result.reason, 'errors_recovered');
+  });
+
+  it('TIER_C: low quality below 50', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ quality: 30, errorsEncountered: 0 });
+    const result = tc._computeQualityTier(ctx, 'SUCCESS', 0);
+    assert.equal(result.tier, 'TIER_C');
+    assert.equal(result.reason, 'low_quality');
+  });
+
+  it('TIER_C: unrecovered errors with low quality', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ quality: 45, errorsEncountered: 3, errorsRecovered: 1 });
+    const result = tc._computeQualityTier(ctx, 'SUCCESS', 2);
+    assert.equal(result.tier, 'TIER_C');
+  });
+
+  it('TIER_B at exactly quality=50 boundary', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ quality: 50, errorsEncountered: 0 });
+    const result = tc._computeQualityTier(ctx, 'SUCCESS', 0);
+    assert.equal(result.tier, 'TIER_B');
+  });
+
+  it('TIER_A at exactly quality=70 boundary', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ quality: 70, errorsEncountered: 0 });
+    const result = tc._computeQualityTier(ctx, 'SUCCESS', 0);
+    assert.equal(result.tier, 'TIER_A');
+  });
+});
+
+describe('TrajectoryCapture — training eligibility', () => {
+  it('eligible when all criteria met', () => {
+    const tc = makeTc();
+    const ctx = makeCtx();
+    const result = tc._computeTrainingEligibility(ctx, 60);
+    assert.equal(result.eligible, true);
+    assert.equal(result.exclusionReason, null);
+  });
+
+  it('ineligible: too_few_steps (< 5)', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ stepCount: 4 });
+    const result = tc._computeTrainingEligibility(ctx, 60);
+    assert.equal(result.eligible, false);
+    assert.equal(result.exclusionReason, 'too_few_steps');
+  });
+
+  it('ineligible: no_actions (no step with type action + tool)', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({
+      allSteps: [
+        { step: 1, type: 'thought', content: 'thinking' },
+        { step: 2, type: 'thought', content: 'more thinking' },
+        { step: 3, type: 'observation', content: 'output' },
+        { step: 4, type: 'thought', content: 'done' },
+        { step: 5, type: 'resolution', content: 'completed' },
+      ],
+    });
+    const result = tc._computeTrainingEligibility(ctx, 60);
+    assert.equal(result.eligible, false);
+    assert.equal(result.exclusionReason, 'no_actions');
+  });
+
+  it('ineligible: no_observations', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({
+      allSteps: [
+        { step: 1, type: 'thought', content: 'thinking' },
+        { step: 2, type: 'action', tool: 'Bash', content: 'run' },
+        { step: 3, type: 'thought', content: 'hmm' },
+        { step: 4, type: 'action', tool: 'Edit', content: 'edit' },
+        { step: 5, type: 'resolution', content: 'done' },
+      ],
+    });
+    const result = tc._computeTrainingEligibility(ctx, 60);
+    assert.equal(result.eligible, false);
+    assert.equal(result.exclusionReason, 'no_observations');
+  });
+
+  it('ineligible: insufficient_tokens (< 500)', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ totalTokens: 400 });
+    const result = tc._computeTrainingEligibility(ctx, 60);
+    assert.equal(result.eligible, false);
+    assert.equal(result.exclusionReason, 'insufficient_tokens');
+  });
+
+  it('ineligible: too_short (duration < 10s)', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ totalTokens: 5000 });
+    const result = tc._computeTrainingEligibility(ctx, 9);
+    assert.equal(result.eligible, false);
+    assert.equal(result.exclusionReason, 'too_short');
+  });
+
+  it('eligible at exact boundary values', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ stepCount: 5, totalTokens: 500 });
+    const result = tc._computeTrainingEligibility(ctx, 10);
+    assert.equal(result.eligible, true);
+    assert.equal(result.exclusionReason, null);
+  });
+
+  it('exclusion reasons follow priority order', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({
+      stepCount: 3,
+      totalTokens: 100,
+      allSteps: [
+        { step: 1, type: 'thought', content: 'thinking' },
+        { step: 2, type: 'thought', content: 'more' },
+        { step: 3, type: 'thought', content: 'done' },
+      ],
+    });
+    const result = tc._computeTrainingEligibility(ctx, 5);
+    assert.equal(result.exclusionReason, 'too_few_steps');
+  });
+});
+
+describe('TrajectoryCapture — user feedback emission', () => {
+  it('emits accepted signal on SUCCESS with 0 interventions and 0 revisions', () => {
+    const tc = makeTc();
+    const captured = [];
+    tc._signAndTransmit = (_sid, envelope) => { captured.push(envelope); };
+
+    const ctx = makeCtx({ revisionRounds: 0 });
+    ctx.stepCount = 10;
+    tc._emitUserFeedback(ctx, 'SUCCESS', 0);
+
+    assert.equal(captured.length, 1);
+    assert.equal(captured[0].type, 'USER_FEEDBACK');
+    assert.equal(captured[0].feedback.signal, 'accepted');
+    assert.equal(captured[0].feedback.revision_rounds, 0);
+    assert.equal(captured[0].feedback.target_step, 10);
+  });
+
+  it('emits iterated signal on SUCCESS with revision rounds > 0', () => {
+    const tc = makeTc();
+    const captured = [];
+    tc._signAndTransmit = (_sid, envelope) => { captured.push(envelope); };
+
+    const ctx = makeCtx({ revisionRounds: 3 });
+    ctx.stepCount = 25;
+    tc._emitUserFeedback(ctx, 'SUCCESS', 2);
+
+    assert.equal(captured.length, 1);
+    assert.equal(captured[0].feedback.signal, 'iterated');
+    assert.equal(captured[0].feedback.revision_rounds, 3);
+    assert.ok(captured[0].feedback.context.includes('3 revision'));
+  });
+
+  it('does not emit feedback on non-SUCCESS status', () => {
+    const tc = makeTc();
+    const captured = [];
+    tc._signAndTransmit = (_sid, envelope) => { captured.push(envelope); };
+
+    const ctx = makeCtx({ revisionRounds: 0 });
+    tc._emitUserFeedback(ctx, 'CRASH', 0);
+
+    assert.equal(captured.length, 0);
+  });
+
+  it('does not emit feedback when SHUTDOWN', () => {
+    const tc = makeTc();
+    const captured = [];
+    tc._signAndTransmit = (_sid, envelope) => { captured.push(envelope); };
+
+    const ctx = makeCtx({ revisionRounds: 0 });
+    tc._emitUserFeedback(ctx, 'SHUTDOWN', 0);
+
+    assert.equal(captured.length, 0);
+  });
+
+  it('feedback envelope has correct structure', () => {
+    const tc = makeTc();
+    const captured = [];
+    tc._signAndTransmit = (_sid, envelope) => { captured.push(envelope); };
+
+    const ctx = makeCtx({ revisionRounds: 0 });
+    ctx.stepCount = 15;
+    tc._emitUserFeedback(ctx, 'SUCCESS', 0);
+
+    const fb = captured[0];
+    assert.ok(fb.envelope_id.startsWith('env_'));
+    assert.equal(fb.session_id, 'sess_test_1');
+    assert.equal(fb.type, 'USER_FEEDBACK');
+    assert.ok(fb.attestation);
+    assert.ok(fb.feedback.timestamp > 0);
+    assert.equal(fb.feedback.delta_summary, null);
+  });
+});
+
+describe('TrajectoryCapture — _computeQuality', () => {
+  it('base score is 50', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ allSteps: [] });
+    ctx.coordinationEvents = 0;
+    ctx.errorsRecovered = 0;
+    ctx.stepCount = 0;
+    const quality = tc._computeQuality(ctx);
+    assert.equal(quality, 50);
+  });
+
+  it('correction adds 10 points', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({
+      allSteps: [{ step: 1, type: 'correction', content: 'fix' }],
+    });
+    ctx.coordinationEvents = 0;
+    ctx.errorsRecovered = 0;
+    ctx.stepCount = 1;
+    const quality = tc._computeQuality(ctx);
+    assert.ok(quality >= 60);
+  });
+
+  it('coordination adds 10 points', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({ allSteps: [] });
+    ctx.coordinationEvents = 1;
+    ctx.errorsRecovered = 0;
+    ctx.stepCount = 0;
+    const quality = tc._computeQuality(ctx);
+    assert.equal(quality, 60);
+  });
+
+  it('caps at 100', () => {
+    const tc = makeTc();
+    const ctx = makeCtx({
+      allSteps: [
+        { step: 1, type: 'correction' },
+        { step: 2, type: 'thought' },
+        { step: 3, type: 'action' },
+        { step: 4, type: 'observation' },
+        ...Array.from({ length: 16 }, (_, i) => ({ step: i + 5, type: 'thought' })),
+      ],
+    });
+    ctx.coordinationEvents = 5;
+    ctx.errorsRecovered = 3;
+    ctx.stepCount = 20;
+    const quality = tc._computeQuality(ctx);
+    assert.equal(quality, 100);
+  });
+});