@@ -1573,6 +1573,49 @@ async function changeWorkMetaOn(sitePath, ref, change) {
     });
 }
 
+/**
+ * Moves the applied-patch record onto the branch a carry just took the files
+ * to (#236).
+ *
+ * A carry is `branch` plus `checkout`: HEAD moves and the worktree is left
+ * alone, so the edits ride along. The record describing them did not, and the
+ * two ended in different places — the changes on the ticket, the claim about
+ * them on trunk. Returning to trunk then met a panel naming a patch, counting
+ * its files and offering to revert it over a clean tree, and the revert failed
+ * blaming a trunk update that never happened.
+ *
+ * One `changeSiteMeta`, because the clear and the write have to be indivisible:
+ * split in two, a concurrent write leaves the record in both places or in
+ * neither, and neither is the worse of the two — it takes the patch text with
+ * it, which is what Revert reverses with.
+ *
+ * Called after the branch's own meta is written, so the entry exists with its
+ * branch point rather than being created here holding this one field (#172).
+ *
+ * @param {string} sitePath
+ * @param {string} ref      The branch the work was carried onto.
+ */
+async function carryAppliedPatch(sitePath, ref) {
+    await changeSiteMeta(sitePath, (m) => {
+        const carried = m.appliedPatch;
+        if (!carried) return m;
+        const branches = { ...(m.branches || {}) };
+        // No entry means nowhere per-branch for it to live, and the reader
+        // would look at the site for it anyway (workMetaScope). Leaving it on
+        // trunk is wrong but visible; moving it somewhere unread is not.
+        if (!branches[ref]) return m;
+        // A patch applied while this link was still running belongs to the
+        // branch and is newer. Overwriting it with trunk's would drop the text
+        // Revert reverses with, leaving a patch on disk the app cannot undo —
+        // the same loss this function exists to prevent, in the other
+        // direction. Trunk's record is left where it is, visibly wrong, rather
+        // than taking a newer one down with it.
+        if (branches[ref].appliedPatch) return m;
+        branches[ref] = { ...branches[ref], appliedPatch: carried };
+        return { ...m, appliedPatch: null, branches };
+    });
+}
+
 async function writeWorkMeta(sitePath, patch) {
     const { ref } = await activeBranch(sitePath);
     return writeWorkMetaOn(sitePath, ref, patch);
@@ -2882,7 +2925,12 @@ ipcMain.handle('sites:set-ticket', async (event, sitePath, ref, options) => with
 		lastUsedAt: new Date().toISOString()
 	});
 	await mergeSiteMeta(sitePath, { tracTicket: parsed.id, currentBranch: checkoutRef });
-	if (carriedFrom === TRUNK) reportCarriedWork(event, sitePath, parsed.id);
+	if (carriedFrom === TRUNK) {
+		// The record travels with the files (#236), before the notice that
+		// says they arrived.
+		await carryAppliedPatch(sitePath, branchRef);
+		reportCarriedWork(event, sitePath, parsed.id);
+	}
 	return { ok: true, ticket: parsed.id, branch: checkoutRef, ...impact };
 }));
 
 
@@ -232,3 +232,49 @@ new file mode 100644
 	const meta = session.readSettings().siteMeta[ site.dir ];
 	expect( meta.branches[ 'ticket/60001' ].appliedPatch ).toBeFalsy();
 } );
+
+test( 'work carried into a ticket takes the applied-patch record with it (#236)', async ( { session } ) => {
+	const site = await makeSite( session );
+	const { page } = await session.start( site.settings );
+
+	// Applied on trunk, before any ticket is known — the order that produced
+	// the bug. The edits are loose on the site, and so is the record.
+	const patch = makePatchFile( session, 'ticket-60001.patch', [
+		{ file: 'wp-login.php', from: TRUNK_LOGIN, to: PATCHED_LOGIN },
+	] );
+	await applyPatchFile( session, patch );
+	await expect( page.getByRole( 'button', { name: 'Revert this patch', exact: true } ) ).toBeVisible( {
+		timeout: 60_000,
+	} );
+
+	// Linking a ticket now asks what happens to the loose work (#234). Taking
+	// it along is the path under test.
+	await page.getByLabel( 'Trac ticket number or URL' ).first().fill( '60001' );
+	await page.getByRole( 'button', { name: 'Link ticket', exact: true } ).first().click();
+	await page.getByRole( 'button', { name: 'Take these edits into #60001', exact: true } ).click();
+	await expect( page.getByText( '#60001', { exact: true } ).first() ).toBeVisible( { timeout: 30_000 } );
+
+	// INVARIANT — the files came along.
+	expect( read( site.dir, LOGIN ) ).toBe( `${ PATCHED_LOGIN }\n` );
+
+	// INVARIANT — and so did the claim about them. Split, this is the bug: the
+	// changes on the ticket, the record on trunk.
+	const carried = session.readSettings().siteMeta[ site.dir ];
+	expect( carried.branches[ 'ticket/60001' ].appliedPatch.label ).toBe( 'ticket-60001.patch' );
+	expect( carried.appliedPatch ).toBeFalsy();
+
+	// INVARIANT — and the offer to undo is still on screen, against the branch
+	// that now holds both halves.
+	await expect( page.getByRole( 'button', { name: 'Revert this patch', exact: true } ) ).toBeVisible( {
+		timeout: 60_000,
+	} );
+
+	// The moment the report was about: back on trunk, over a tree that holds
+	// none of it, the app used to name the patch, count its files and offer to
+	// revert it.
+	await page.getByRole( 'button', { name: 'Unlink', exact: true } ).click();
+	await expect( page.getByRole( 'button', { name: 'Revert this patch', exact: true } ) ).toHaveCount( 0, {
+		timeout: 30_000,
+	} );
+	expect( gitOk( [ 'status', '--porcelain' ], site.dir ).trim() ).toBe( '' );
+} );
@@ -4484,6 +4484,79 @@ test('sites:set-ticket says how much loose work the chosen carry took into a new
 	assert.match(fs.readFileSync(path.join(dir, 'wp-login.php'), 'utf8'), /before the ticket was known/);
 });
 
+// The record belongs with the work (#236). A carry moves the files onto the
+// branch; leaving the applied-patch record behind on trunk is what made the
+// panel greet a returning contributor with a patch it named, counted and
+// offered to revert, over a tree that no longer held any of it — and the
+// revert then blamed a trunk update that never happened.
+test('the carry takes the applied-patch record onto the ticket with the files (issue #236)', async (t) => {
+	const dir = dirtyTrunkFixture(t, 'ipc-wiring-carry-patch-');
+	const applied = {
+		label: '62281.diff',
+		appliedAt: '2026-09-15T08:22:44.741Z',
+		files: ['wp-login.php'],
+		text: 'diff --git a/wp-login.php b/wp-login.php\n'
+	};
+	const settings = fakeSettingsStore({ sites: [dir], siteMeta: { [dir]: { appliedPatch: applied } } });
+	const main = loadMain({ stubs: { ...silentLogging(), ...settings.stubs } });
+
+	const event = createIpcEvent();
+	assert.equal((await main.invokeWith('sites:set-ticket', event, dir, '62281', { carryTrunkWork: true })).ok, true);
+	// The count runs after the handler answers, on a Git child of its own.
+	// Waiting for its notice is what says that child is done — on Windows an
+	// unfinished one holds the fixture directory open and the teardown cannot
+	// delete it.
+	assert.ok(await carriedWork(event), 'the carry finished and said so');
+
+	const meta = settings.values.siteMeta[dir];
+	assert.deepEqual(
+		meta.branches['ticket/62281'].appliedPatch,
+		applied,
+		'the whole record travels, the patch text included — it is what Revert reverses with'
+	);
+	assert.ok(!meta.appliedPatch, 'and trunk stops claiming a patch whose files it no longer holds');
+});
+
+// The window between creating the branch and moving the record: a patch
+// applied in it is recorded against the branch and is the newer of the two.
+// Overwriting it would drop the text Revert reverses with, leaving a patch on
+// disk the app cannot undo — the loss the carry exists to prevent, arriving
+// from the other side.
+test('the carry does not overwrite a patch recorded against the branch while it ran (issue #236)', async (t) => {
+	const dir = dirtyTrunkFixture(t, 'ipc-wiring-carry-patch-race-');
+	const fromTrunk = { label: 'older.diff', appliedAt: '2026-09-15T08:00:00.000Z', files: ['wp-login.php'], text: 'older\n' };
+	const onBranch = { label: 'newer.diff', appliedAt: '2026-09-15T08:30:00.000Z', files: ['wp-login.php'], text: 'newer\n' };
+	const settings = fakeSettingsStore({
+		sites: [dir],
+		siteMeta: { [dir]: { appliedPatch: fromTrunk, branches: { 'ticket/62281': { appliedPatch: onBranch } } } }
+	});
+	const main = loadMain({ stubs: { ...silentLogging(), ...settings.stubs } });
+
+	const event = createIpcEvent();
+	assert.equal((await main.invokeWith('sites:set-ticket', event, dir, '62281', { carryTrunkWork: true })).ok, true);
+	assert.ok(await carriedWork(event), 'the carry finished and said so — see the note in the test above');
+
+	const meta = settings.values.siteMeta[dir];
+	assert.deepEqual(meta.branches['ticket/62281'].appliedPatch, onBranch, 'the newer record survives');
+	assert.deepEqual(meta.appliedPatch, fromTrunk, 'and the older one is left where it is rather than taken down with it');
+});
+
+// The other half of the same rule: a carry the contributor declined moves
+// nothing, so a patch applied on trunk stays trunk's. Without this the fix
+// above could satisfy its test by clearing the record unconditionally.
+test('declining the carry leaves the applied-patch record on trunk (issue #236)', async (t) => {
+	const dir = dirtyTrunkFixture(t, 'ipc-wiring-carry-patch-declined-');
+	const applied = { label: '62281.diff', appliedAt: '2026-09-15T08:22:44.741Z', files: ['wp-login.php'], text: 'diff\n' };
+	const settings = fakeSettingsStore({ sites: [dir], siteMeta: { [dir]: { appliedPatch: applied } } });
+	const main = loadMain({ stubs: { ...silentLogging(), ...settings.stubs } });
+
+	const event = createIpcEvent();
+	const result = await main.invokeWith('sites:set-ticket', event, dir, '62281');
+
+	assert.equal(result.code, 'dirty-trunk', 'the gesture asks rather than moving anything');
+	assert.deepEqual(settings.values.siteMeta[dir].appliedPatch, applied, 'nothing moved, so the record did not either');
+});
+
 test('nothing loose means nothing is claimed (issue #108)', async (t) => {
 	const dir = adoptedRepo(t, 'ipc-wiring-carry-clean-');
 	fs.writeFileSync(path.join(dir, 'wp-login.php'), '<?php // trunk\n');