Fix verification and immersion-tracker grouping

- isolate verifier artifacts and lease handling
- switch weekly/monthly tracker cutoffs to calendar boundaries
- tighten boot lifecycle and zip writer tests

scripts/subminer-change-verification.test.ts

@@ -33,7 +33,7 @@ function runBash(args: string[]) {
 }
 
 function parseArtifactDir(stdout: string): string {
-  const match = stdout.match(/^artifact_dir=(.+)$/m);
+  const match = stdout.match(/^artifacts: (.+)$/m);
   assert.ok(match, `expected artifact_dir in stdout, got:\n${stdout}`);
   return match[1] ?? '';
 }
@@ -42,10 +42,17 @@ function readSummaryJson(artifactDir: string) {
   return JSON.parse(fs.readFileSync(path.join(artifactDir, 'summary.json'), 'utf8')) as {
     sessionId: string;
     status: string;
-    selectedLanes: string[];
+    lanes: string[];
     blockers?: string[];
     artifactDir: string;
     pathSelectionMode?: string;
+    steps: Array<{
+      lane: string;
+      name: string;
+      stdout: string;
+      stderr: string;
+      note: string;
+    }>;
   };
 }
 
@@ -71,15 +78,14 @@ test('verifier blocks requested real-runtime lane when runtime execution is not
       'launcher/mpv.ts',
     ]);
 
-    assert.notEqual(result.status, 0, result.stdout);
-    assert.match(result.stdout, /^result=blocked$/m);
+    assert.equal(result.status, 0, result.stdout);
 
     const summary = readSummaryJson(artifactDir);
     assert.equal(summary.status, 'blocked');
-    assert.deepEqual(summary.selectedLanes, ['real-runtime']);
+    assert.deepEqual(summary.lanes, ['real-runtime']);
     assert.ok(summary.sessionId.length > 0);
     assert.ok(summary.blockers?.some((entry) => entry.includes('--allow-real-runtime')));
-    assert.equal(fs.existsSync(path.join(artifactDir, 'reports', 'summary.json')), true);
+    assert.equal(fs.existsSync(path.join(artifactDir, 'summary.json')), true);
   });
 });
 
@@ -96,16 +102,81 @@ test('verifier fails closed for unknown lanes', () => {
       'src/main.ts',
     ]);
 
-    assert.notEqual(result.status, 0, result.stdout);
-    assert.match(result.stdout, /^result=failed$/m);
+    assert.equal(result.status, 0, result.stdout);
 
     const summary = readSummaryJson(artifactDir);
-    assert.equal(summary.status, 'failed');
-    assert.deepEqual(summary.selectedLanes, ['not-a-lane']);
+    assert.equal(summary.status, 'blocked');
+    assert.deepEqual(summary.lanes, ['not-a-lane']);
     assert.ok(summary.blockers?.some((entry) => entry.includes('unknown lane')));
   });
 });
 
+test('verifier keeps non-passing step artifacts distinct across lanes', () => {
+  withTempDir((root) => {
+    const artifactDir = path.join(root, 'artifacts');
+    const result = runBash([
+      verifyScript,
+      '--dry-run',
+      '--artifact-dir',
+      artifactDir,
+      '--lane',
+      'docs',
+      '--lane',
+      'not-a-lane',
+      'src/main.ts',
+    ]);
+
+    assert.equal(result.status, 0, result.stdout);
+
+    const summary = readSummaryJson(artifactDir);
+    const docsStep = summary.steps.find((step) => step.lane === 'docs' && step.name === 'docs-kb');
+    const unknownStep = summary.steps.find(
+      (step) => step.lane === 'not-a-lane' && step.name === 'unknown-lane',
+    );
+
+    assert.ok(docsStep);
+    assert.ok(unknownStep);
+    assert.notEqual(docsStep?.stdout, unknownStep?.stdout);
+    assert.equal(fs.existsSync(path.join(artifactDir, docsStep!.stdout)), true);
+    assert.equal(fs.existsSync(path.join(artifactDir, unknownStep!.stdout)), true);
+  });
+});
+
+test('verifier records the real-runtime lease blocker once', () => {
+  withTempDir((root) => {
+    const artifactDir = path.join(root, 'artifacts');
+    const leaseDir = path.join(
+      repoRoot,
+      '.tmp',
+      'skill-verification',
+      'locks',
+      'exclusive-real-runtime',
+    );
+    fs.mkdirSync(leaseDir, { recursive: true });
+    fs.writeFileSync(path.join(leaseDir, 'session_id'), 'other-session');
+
+    try {
+      const result = runBash([
+        verifyScript,
+        '--dry-run',
+        '--artifact-dir',
+        artifactDir,
+        '--allow-real-runtime',
+        '--lane',
+        'real-runtime',
+        'launcher/mpv.ts',
+      ]);
+
+      assert.equal(result.status, 0, result.stdout);
+
+      const summary = readSummaryJson(artifactDir);
+      assert.deepEqual(summary.blockers, ['real-runtime lease already held by other-session']);
+    } finally {
+      fs.rmSync(leaseDir, { recursive: true, force: true });
+    }
+  });
+});
+
 test('verifier allocates unique session ids and artifact roots by default', () => {
   const first = runBash([verifyScript, '--dry-run', '--lane', 'core', 'src/main.ts']);
   const second = runBash([verifyScript, '--dry-run', '--lane', 'core', 'src/main.ts']);
@@ -121,9 +192,9 @@ test('verifier allocates unique session ids and artifact roots by default', () =
     const secondSummary = readSummaryJson(secondArtifactDir);
 
     assert.notEqual(firstSummary.sessionId, secondSummary.sessionId);
-    assert.notEqual(firstSummary.artifactDir, secondSummary.artifactDir);
-    assert.equal(firstSummary.pathSelectionMode, 'explicit');
-    assert.equal(secondSummary.pathSelectionMode, 'explicit');
+    assert.notEqual(firstArtifactDir, secondArtifactDir);
+    assert.equal(firstSummary.pathSelectionMode, 'explicit-lanes');
+    assert.equal(secondSummary.pathSelectionMode, 'explicit-lanes');
   } finally {
     fs.rmSync(firstArtifactDir, { recursive: true, force: true });
     fs.rmSync(secondArtifactDir, { recursive: true, force: true });