test: cover release refusal branches, text rendering, and orphan warnings

Changed-line coverage on the stale-release slice was 69.33% against the 70%
gate: the refusal-reason branches, the text-mode outcome rendering with the
live-owner hint, and the daemon stop orphaned-claim warning had no tests.
Cover them directly; the misnamed-claim-file refusal is also pinned.

Author: thymikee

src/__tests__/cli-device-release.test.ts

@@ -128,3 +128,39 @@ test('device status --stale offers the exact release command for provably dead o
     fs.rmSync(claimsDir, { recursive: true, force: true });
   }
 });
+
+test('device release --stale renders per-claim outcomes with a live-owner hint in text mode', async () => {
+  const claimsDir = mkdtempForTestSync('agent-device-cli-release-');
+  const stateDir = mkdtempForTestSync('agent-device-cli-release-state-');
+  const owner = readCurrentOwnerIdentity();
+  try {
+    writeClaim(claimsDir, {
+      deviceKey: 'local:android:none:emulator-5554',
+      id: 'emulator-5554',
+      name: 'Dead Pixel',
+      session: 'dead-session',
+      ownerPid: 999_999_999,
+      ownerStartTime: 'old-start-time',
+      stateDir,
+    });
+    writeClaim(claimsDir, {
+      deviceKey: 'local:android:none:emulator-5556',
+      id: 'emulator-5556',
+      name: 'Live Pixel',
+      session: 'live-session',
+      ownerPid: owner.pid,
+      ownerStartTime: owner.startTime,
+      stateDir: process.cwd(),
+    });
+
+    const result = await runCliCapture(['device', 'release', '--stale'], {
+      env: { AGENT_DEVICE_CLAIMS_DIR: claimsDir },
+    });
+    assert.match(result.stdout, /released android Dead Pixel session=dead-session/);
+    assert.match(result.stdout, /refused android Live Pixel session=live-session[^\n]*live-owner/);
+    assert.match(result.stdout, /agent-device daemon stop --state-dir/);
+  } finally {
+    fs.rmSync(claimsDir, { recursive: true, force: true });
+    fs.rmSync(stateDir, { recursive: true, force: true });
+  }
+});

src/cli/commands/__tests__/daemon.test.ts

@@ -139,3 +139,40 @@ test('reports graceful provider cleanup as unknown when the shutdown report is u
     fs.rmSync(stateDir, { recursive: true, force: true });
   }
 });
+
+test('warns in text output when a graceful stop leaves an orphaned claim', async () => {
+  const stateDir = mkdtempForTestSync('agent-device-daemon-command-');
+  mocks.readDaemonStopIdentity.mockReturnValue({ pid: 123, processStartTime: 'start-time' });
+  mocks.stopDaemon.mockResolvedValue(GRACEFUL_RESULT);
+  const claim = {
+    deviceKey: 'local:android:none:emulator-5554',
+    session: 'default',
+    platform: 'android',
+    deviceId: 'emulator-5554',
+  };
+  mocks.readDaemonShutdownReport.mockReturnValue({
+    providerReleases: { released: [], pending: [] },
+    claims: { released: [], orphaned: [claim], superseded: [] },
+  });
+
+  try {
+    await daemonCommand({
+      positionals: ['stop'],
+      flags: { clean: false, help: false, json: false, stateDir, version: false },
+      client: {} as never,
+    });
+
+    const [, data, renderHuman] = mocks.writeCommandOutput.mock.calls.at(-1) ?? [];
+    expect(data).toEqual(
+      expect.objectContaining({
+        claimsOrphaned: [claim],
+        warnings: [expect.stringContaining('was not released cleanly')],
+      }),
+    );
+    const rendered = (renderHuman as () => string)();
+    expect(rendered).toContain('Ownership of emulator-5554 was not released cleanly');
+    expect(rendered).toContain('agent-device device release --stale');
+  } finally {
+    fs.rmSync(stateDir, { recursive: true, force: true });
+  }
+});

src/daemon/__tests__/device-claims.test.ts

@@ -754,3 +754,59 @@ test('release refuses live owners and corrupt claims without touching them', asy
   assert.equal(fs.existsSync(claimPath(root)), true);
   assert.equal(fs.existsSync(path.join(root, 'corrupt.json')), true);
 });
+
+test('release names the exact refusal for uncertain owners and misnamed claim files', async () => {
+  const root = useClaimsRoot();
+  const acquired = await acquireDeviceClaim({
+    device,
+    session: 'reused-owner',
+    workspace: '/worktrees/reused',
+    stateDir: root,
+  });
+  assert.equal(acquired.status, 'acquired');
+  const stored = JSON.parse(fs.readFileSync(claimPath(root), 'utf8')) as Record<string, unknown>;
+  // Same PID, different recorded start time: PID reuse, uncertain ownership.
+  fs.writeFileSync(claimPath(root), JSON.stringify({ ...stored, ownerStartTime: 'other-start' }));
+  // A dead-owner claim stored under a name that is not the hash of its own
+  // device key: the claim lock protects a different path, so release refuses.
+  fs.writeFileSync(
+    path.join(root, 'misnamed.json'),
+    JSON.stringify({
+      ...stored,
+      deviceKey: 'local:android:none:misnamed-device',
+      device: { ...(stored.device as object), id: 'misnamed-device' },
+      ownerPid: 999_999_999,
+      ownerStartTime: 'long-gone',
+      session: 'misnamed-owner',
+    }),
+  );
+
+  const outcomes = await releaseProvenStaleDeviceClaims({
+    selectors: {},
+    reconcile: async () => ({ status: 'reconciled' }),
+  });
+  const reasons = new Map(outcomes.map((outcome) => [outcome.session, outcome.reason]));
+  assert.equal(reasons.get('reused-owner'), 'owner-pid-reused');
+  assert.equal(reasons.get('misnamed-owner'), 'claim-file-name-mismatch');
+  assert.ok(outcomes.every((outcome) => outcome.status === 'refused'));
+  assert.equal(fs.existsSync(path.join(root, 'misnamed.json')), true);
+});
+
+test('release refuses a live process whose state dir is gone', async () => {
+  const root = useClaimsRoot();
+  const acquired = await acquireDeviceClaim({
+    device,
+    session: 'dir-gone-owner',
+    workspace: '/worktrees/dir-gone',
+    stateDir: path.join(root, 'missing-state-dir'),
+  });
+  assert.equal(acquired.status, 'acquired');
+
+  const outcomes = await releaseProvenStaleDeviceClaims({
+    selectors: {},
+    reconcile: async () => ({ status: 'reconciled' }),
+  });
+  assert.equal(outcomes[0]?.status, 'refused');
+  assert.equal(outcomes[0]?.reason, 'owner-process-still-running');
+  assert.equal(fs.existsSync(claimPath(root)), true);
+});