@@ -42,28 +42,38 @@ test('v1, v2, and v3 records decode to the process-owned claim with its process
     expect(record.session).toBe('work');
     expect(record.ownerPid).toBe(4242);
     expect(record.ownerToken).toBe('token');
+    expect(record.transientCommand).toBeUndefined();
   }
 });
 
-test('a legacy claim claim-kind comes from the label that encoded it, once at the boundary', () => {
-  // The pre-kind schemas recorded a command-scoped claim only as a `transient:<command>` session.
+// Released v1/v2 recorded a command-scoped claim and an open session *named* `transient:<command>`
+// as the same record — no stored field separates them, so the kind of a legacy claim is not a
+// fact the decoder can read. Both decode kindless, which is safe by construction, not by guess:
+// the kind is consulted only for claims `isClaimOwnedByThisDaemon` accepts (same stateDir, pid,
+// and process start time), and a live process reads and writes only v3 records, whose kind is a
+// stored field. No in-flight command's claim is ever a legacy record; the original #3345 bypass
+// needs a current-process claim, which carries its kind.
+test('a legacy claim with a command-label session decodes kindless, not as a guessed command claim', () => {
   for (const raw of [
     legacyClaim({ session: 'transient:install' }),
-    v2Claim({ session: 'transient:reinstall' }),
+    v2Claim({ session: 'transient:install' }),
   ]) {
-    expect(decodeStoredDeviceClaim(raw)?.transientCommand).toBe(
-      raw.session === 'transient:install' ? 'install' : 'reinstall',
-    );
+    const record = decodeStoredDeviceClaim(raw);
+    expect(record?.transientCommand).toBeUndefined();
+    expect(record?.session).toBe('transient:install');
   }
-  // From v3 the kind is a stored field, not a label pattern: a v3 open session may be named
-  // after a command, and a v3 record without the field is that session's claim.
+});
+
+// The kind is a stored field from v3 on. A v3 open session may be named after a command, and a
+// v3 record without the field is exactly that session's claim; a malformed kind fails the record
+// closed instead of guessing.
+test('a v3 claim kind comes only from its stored field', () => {
   expect(
     decodeStoredDeviceClaim(currentClaim({ session: 'transient:install' }))?.transientCommand,
   ).toBeUndefined();
   expect(
     decodeStoredDeviceClaim(currentClaim({ transientCommand: 'install' }))?.transientCommand,
   ).toBe('install');
-  // A malformed kind fails the record closed instead of guessing a kind.
   expect(decodeStoredDeviceClaim(currentClaim({ transientCommand: '' }))).toBeNull();
   expect(decodeStoredDeviceClaim(currentClaim({ transientCommand: 7 }))).toBeNull();
 });
 
@@ -31,8 +31,9 @@ export type DeviceClaim = {
    * Set when a `transient-exclusive` command took the claim: the command it is scoped to. This is
    * the claim-kind discriminant (#3345) — a command-scoped claim is never an open session's claim,
    * even when its `session` label reads `transient:<command>` and a caller copies that label into
-   * `--session`. Absent means an open session owns it. Legacy records carry no field and get their
-   * kind from the label that encoded it, once, in `decodeStoredDeviceClaim`.
+   * `--session`. Absent means an open session owns it, including every legacy record: a v1/v2
+   * record cannot prove which it was, and no kind decision is ever taken on one (see
+   * {@link decodeStoredDeviceClaim}).
    */
   transientCommand?: string;
   /** Set by `abandonDeviceClaim`; absent while the claim still holds the device for its owner. */
@@ -60,11 +61,22 @@ export function ownershipFromClaim(claim: DeviceClaim): DeviceClaimSessionOwners
   };
 }
 
+/**
+ * Legacy (v1/v2) records decode kindless — as open-session claims — because they cannot state a
+ * kind: released v1/v2 recorded a command-scoped claim and an open session *named*
+ * `transient:<command>` identically, so the label is no proof of kind. Decoding kindless is safe
+ * by construction, not by guess: every consumer of a claim's kind first requires
+ * `isClaimOwnedByThisDaemon` (same stateDir, pid, and process start time), and a current process
+ * writes only v3 records whose kind is stored — a legacy record can only be one this process
+ * could not have written, so its owner identity is proven not to match. Recovery for a legacy
+ * record needs nothing special: the recording process still holds its token, and any other owner
+ * is settled or conflicted by the principal-based paths, none of which reads a kind.
+ */
 export function decodeStoredDeviceClaim(value: unknown): DeviceClaim | null {
   if (!isRecord(value)) return null;
   if (value.schemaVersion === DEVICE_CLAIM_SCHEMA_VERSION) return decodeCurrentClaim(value);
-  if (value.schemaVersion === 2) return stampLegacyClaimKind(decodeClaimBody(value));
-  if (value.schemaVersion === 1) return stampLegacyClaimKind(migrateLegacyClaim(value));
+  if (value.schemaVersion === 2) return decodeClaimBody(value);
+  if (value.schemaVersion === 1) return migrateLegacyClaim(value);
   return null;
 }
 
@@ -147,22 +159,6 @@ export function transientDeviceClaimSession(command: string): string {
 
 const TRANSIENT_CLAIM_LABEL_PREFIX = 'transient:';
 
-/**
- * The command a legacy claim's `session` label encodes a command-scoped claim for, or undefined
- * for an open-session label. Records written before the kind field existed encoded it only in
- * that label, so translating it here — once, at the legacy boundary — is what lets every current
- * claim's kind be a stored field: reading the label at decision points is exactly the #3345 bug
- * where a caller could copy `transient:<command>` into `--session` and read as that claim's owner.
- */
-function stampLegacyClaimKind(claim: DecodedClaimBody | null): DeviceClaim | null {
-  if (!claim) return null;
-  if (!claim.session.startsWith(TRANSIENT_CLAIM_LABEL_PREFIX)) return claim;
-  const transientCommand = claim.session.slice(TRANSIENT_CLAIM_LABEL_PREFIX.length);
-  // A bare `transient:` label was never a command claim: command names are non-empty, so such a
-  // claim could only have been an open session with that literal name.
-  return transientCommand === '' ? claim : { ...claim, transientCommand };
-}
-
 function decodeClaimLocation(
   raw: Record<string, unknown>,
 ): Pick<DeviceClaim, 'deviceKey' | 'session' | 'workspace' | 'stateDir'> | null {
 
@@ -208,6 +208,37 @@ test('an in-flight transient claim refuses a request named after its label, whil
   expect(claimedSessions()).toEqual(['transient:install']);
 });
 
+// The label-guard branch in acquireTransientDeviceClaim: the open session's claim below is
+// named exactly this command's label, and a DIFFERENT session's `install` builds the same
+// label as its own claim session. Without the guard, resolveExistingClaim's raw string match
+// would hand that request the open session's release token (a renew-adopt), and disposing it
+// would delete a claim it never took. Mutation: drop the guard — the foreign session acquires,
+// and its dispose unlinks the open session's claim.
+test("an open session named after a command's label is not renew-adopted by that command's requests", async () => {
+  const { stateDir } = setup();
+  const open = await acquireDeviceClaim({
+    device: ANDROID_EMULATOR,
+    session: 'transient:install',
+    workspace: '/worktrees/current',
+    stateDir,
+    reconcileOrphanedDeviceClaim: retainOrphanedDeviceClaims,
+  });
+  expect(open.status).toBe('acquired');
+  if (open.status !== 'acquired') return;
+
+  const foreign = makeAdmission('transient-exclusive', stateDir, 'install', 'other-session');
+  const error = asAppError(
+    await foreign.admit(ANDROID_EMULATOR, localAndroid).catch((error: unknown) => error),
+  );
+  expect(error.code).toBe('DEVICE_IN_USE');
+  await foreign[Symbol.asyncDispose]();
+
+  // The open session's claim survived, with its original token: nothing was adopted.
+  const held = inspectDeviceClaims({})[0]?.claim;
+  expect(held?.ownerToken).toBe(open.ownership.ownerToken);
+  expect(await abandonDeviceClaim(open.ownership)).toBe('abandoned');
+});
+
 test("another request in flight's transient claim of the same command refuses, and holds nothing", async () => {
   const { stateDir } = setup();
   const held = await acquireDeviceClaim({
 
@@ -433,11 +433,12 @@ async function runAndroidSetupAndInstallWorkflow(
   assert.equal(push.action, 'com.example.demo.PUSH');
   assert.equal(push.extrasCount, 3);
 
-  // #3345: a claim covers a raw request only from its own session AND its own workspace. The
-  // client calls above carried no cwd, so the open claimed this checkout at the `default`
-  // address; these pushes join that address the way `--session` does and run from a directory
-  // inside the checkout, so their relative payloads resolve against `cwd` as a real call's
-  // does. A foreign workspace would refuse even under the same name — the copyable-address rule.
+  // #3345: coverage pairs the routed session with the workspace a claim records. The client
+  // calls above sent no cwd, so their open claim records the daemon-side fallback workspace —
+  // this checkout — at the routed `default` address. These pushes state their provenance
+  // explicitly: sessionExplicit joins that address, and their cwd — a checkout child directory,
+  // chosen so the relative payloads resolve against it — canonicalizes to that recorded
+  // workspace. A foreign cwd refuses even under the same session name: the copyable-address rule.
   fs.mkdirSync(path.join(process.cwd(), '.tmp'), { recursive: true });
   const callerWorkspace = fs.mkdtempSync(path.join(process.cwd(), '.tmp', 'push-'));
   try {