Skip to content

Commit b2ddb4c

Browse files
authored
schedules: a schedule copied to another Bot loses the reach it was set with (#2954)
Fixes #2951 Owner: Dev-1 Written-by: Dev-1 Reviewer: Reviewer Claim-Id: 4d118d616cfe431581c30141ce255969 Base: 2d81af3 Verified commit: d4f1e8d95927ce5ae77d8693060a63ca2f6a11cc (tree 367f26f) Pushed head: 62660a1 Risk tier: T2 (`risk-gate (report only): PR #2954 tier T2`; path-based, no content or size hit) ## What was wrong A schedule copied to another Bot never recorded the reach it was set with, so its card could never say `changed since it was set` — the thing `#2942` landed for created and edited tasks. `copyRow` in `core/src/host/schedules.js` answered `undefined`: its `return id` sat inside the `service.serialize(async () => { … })` callback, not outside it. `copySchedule` hands that answer to `noteTargetReach(createdId, body.target)` at `:424`; `noteReachAtSet` refuses a non-string id at `:268`, so nothing was written to `state.scheduleCarriedAtSet` and `rt.save()` never ran. The row itself was written — the copy appeared — only its reach-at-set was missing. The client (`core/src/client/schedules.js` `reachMoved`) reads a non-array `carriedAtSet` as unchanged, so the hint never appended `changed since it was set`. The paused-source branch goes through `service.create` and was already fine; only the active-source copy path was broken. Nothing about the shape of `state.scheduleCarriedAtSet` changes. ## What changed - `core/src/host/schedules.js`: `copyRow` now `return await service.serialize(…)`, so the new row's id leaves the write and reaches `noteTargetReach`. A short comment names why the id has to leave. - `core/test/schedules.test.js`: one new case, `#2951`. Composio is off for `w1` when the source is created (its own set is `['github']`), turned on before the copy, and the copy to `m1` asserts `carriedAtSet === ['github', 'composio']` — the target's reach at the copy, never the source's stored set — and `carried` equal to it. Then Composio is turned off for `m1`: the stored set must stay and only `carried` move, which proves the set reached the saved state and not only the reply. - `docs/subsystems/core-host.md`: the `schedules.js` row now says a copy is set at the copy, with the target's reach, and that the write happens only when `copyRow` answers the new row's id. - `changelog.d/2951-schedules-copy-reach.fixed.md`: one fragment. - `patches/ds-bot/0001-core-fixes.patch`: regenerated once, after the edit, from the committed tree. `core/src/client/**`, `core/client.js` and `patches/ds-bot/0008-client-bundle.patch` are untouched. ## Red first, on base `2d81af3658e9` (test in the tree, fix not yet written) `TMPDIR=/tmp TZ=UTC node --test --import ./test/harness-resolve.mjs --test-name-pattern='#2951' test/schedules.test.js`: ``` not ok 1 - \#2951: a copy stores the reach the target has when it is copied, so the card can say it moved error: |- the copy is set with the reach the target has now + actual - expected + undefined - [ - 'github', - 'composio' - ] expected: [ 'github', 'composio' ] actual: undefined ``` The whole file at the same base: `# tests 42 / # pass 41 / # fail 1`, the one red being this case. ## Mutations - Without the fix (the base tree): the new case fails as quoted above — the reply's `carriedAtSet` is `undefined`. - With the fix, but `noteTargetReach` given the source's id (`body.copyFrom?.id`) instead of the new row's: the same case fails 1/1 — the assertion is pinned to the id the copy actually writes, not to the mere presence of a save. - With the fix and the assertion intact: `#2951` passes 1/1 and the whole file is `# tests 42 / # pass 42 / # fail 0`. ## What I ran, at `d4f1e8d95927ce5ae77d8693060a63ca2f6a11cc` (tree `367f26fdbe6ecdb6e11e5e023f6fa47e1f64469c`) - `TZ=UTC npm run verify` (`TMPDIR=/tmp`, `DSH_HARNESS=…`, `ARCH_DOCS_BASE=2d81af3658e9`): core lint `Found 88 warnings and 0 errors`, `arch-docs: OK (5 changed file(s))`, plugin lint `0 errors` for every package, `build-client.mjs --check` ok, `ds-bot-patches check` `ok 10 patches apply cleanly in order` and `ok core/ equals ds-bot/ + patches/ds-bot/`, `canonical` `ok patches/ds-bot/ is what generate writes (generate is a no-op)`, then core `# tests 3179 / # pass 3177 / # fail 2`. - The two core reds are `bench.sh refuses before writing the profile when pnpm is missing` and `bench.sh shows a failed pnpm install and leaves no half-built profile` in `core/test/bench-preflight.test.js`. They are this box, not this change: a clean detached worktree at base `2d81af3658e9` runs the same file `# tests 7 / # pass 5 / # fail 2` with the same two names, and this diff does not touch that file. - Because `npm run verify` stops at that suite, its later steps ran separately at the same commit: `plugins/social` 626/626, `plugins/tree` 149/149, `plugins/timeline` 172/172, `plugins/workflow` 531/531, `plugins/project` 147/147, `.github/scripts` + `policy` 675/675, `changelog.mjs check` `21 fragment(s) … well formed`, `lint:interop` exit 0, `test:interop` exit 0, `lint:live-e2e` exit 0, `test:live-e2e` exit 0 — all exit 0. - `core/test/schedules.test.js` on its own after the fix: `# tests 42 / # pass 42 / # fail 0`. ## Not run - The smoke bench (`dev/bench.sh smoke`) — this box's bench preflight is the known red above (`pnpm` missing), so a bench run would report the environment, not this card; nothing here changes start-up. - No browser/client build: `core/src/client/**` is untouched and `build-client.mjs --check` confirms `client.js` still is the build of `src/client`. ## Checkpoint <!-- flybot:checkpoint --> ```json { "pr": 2954, "claim": "Dev-1", "issue": 2951, "summary": "copyRow answered undefined because its `return id` sat inside the serialize callback, so the copy path handed noteTargetReach a non-string, the reach-at-set was never written and rt.save() never ran: a copied schedule could never say the reach moved since it was set. Returning the id out of serialize fixes it; one test pins the copy to the target's reach at the copy (not the source's stored set) and to the stored set surviving a later roster change. No client change, no bundle.", "files": [ "core/src/host/schedules.js", "core/test/schedules.test.js", "docs/subsystems/core-host.md", "changelog.d/2951-schedules-copy-reach.fixed.md", "patches/ds-bot/0001-core-fixes.patch" ], "checks": { "ran": "TZ=UTC npm run verify (ARCH_DOCS_BASE=2d81af3658e9); plugins/social|tree|timeline|workflow|project test; node --test .github/scripts/*.test.mjs policy/*.test.mjs; lint:interop test:interop lint:live-e2e test:live-e2e; changelog check; schedules file 42/42", "result": "green", "at": "62660a1357008f8a40b44a44dd3b5d02da444130" }, "next": "waiting for a Verdict naming the pushed head" } ``` <!-- /flybot:checkpoint -->
1 parent 54054fb commit b2ddb4c

5 files changed

Lines changed: 70 additions & 5 deletions

File tree

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1 @@
1+
A task copied to another Bot now records the reach that Bot had when it was copied, so its card can say `changed since it was set` once the roster moves. The copy path lost the new task's id on its way out of the write, so the reach-at-set was never stored and the copy looked as if it had always had today's reach. See [#2951](https://github.com/ThinkFlowLab/FlyBot/issues/2951).

‎core/src/host/schedules.js‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -428,7 +428,9 @@ export function install(rt) {
428428
// The row write itself. `put`, `get` and the `tasks` row shape are the same private API
429429
// `moveSchedules` documents above; a renamed `put` or `get` throws here and copies nothing.
430430
async function copyRow(fromSession, sourceId, toSession) {
431-
await service.serialize(async () => {
431+
// The id must leave `serialize`: the caller hands it to `noteTargetReach`, which refuses a
432+
// non-string and then saves nothing, so the copy keeps no reach-at-set (#2951).
433+
return await service.serialize(async () => {
432434
const tasks = (await service.getDomain()).table('tasks')
433435
const source = tasks.get(sourceId)
434436
if (source === undefined || source.sessionId !== fromSession) throw invalid('No such task')

‎core/test/schedules.test.js‎

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1140,3 +1140,33 @@ test('#2930 b: an edit re-stores the reach at the edit, so the marker stops lyin
11401140
assert.deepEqual(row.carriedAtSet, ['github', 'composio'], 'the reader saved it with both on, so both are what it was set with')
11411141
assert.deepEqual(row.carried, ['github', 'composio'])
11421142
})
1143+
1144+
// #2951: a copy is a new task, so it is set at the copy — with the target's reach at that moment.
1145+
// The copy path hands the new row's id to the same `noteTargetReach` create uses, so when
1146+
// `copyRow` drops that id the set is never written, `rt.save()` never runs, and the card can never
1147+
// say the reach moved since it was set.
1148+
test('#2951: a copy stores the reach the target has when it is copied, so the card can say it moved', async (t) => {
1149+
const { rt, call } = await reachSetup(t)
1150+
rt.state.bots.w1.connectors = { composio: false }
1151+
const made = await call('schedule-create', { target: 'w1', title: 'Briefing', prompt: 'Sum up', when: DAILY })
1152+
assert.equal(made.ok, true, JSON.stringify(made))
1153+
const [source] = made.value.tasks
1154+
assert.deepEqual(source.carriedAtSet, ['github'], 'the source was set while Composio was off')
1155+
1156+
// The Bot's reach moves before the copy: Composio is on when the copy is made, so the copy is
1157+
// set with both — the source's stored set is not the copy's set.
1158+
rt.state.bots.w1.connectors = {}
1159+
const copied = await call('schedule-create', { target: 'm1', copyFrom: { sessionId: source.sessionId, id: source.id } })
1160+
assert.equal(copied.ok, true, JSON.stringify(copied))
1161+
const copy = copied.value.tasks.find(task => task.id !== source.id)
1162+
assert.equal(copy.botId, 'm1', 'the copy is listed under the target Bot')
1163+
assert.deepEqual(copy.carriedAtSet, ['github', 'composio'], 'the copy is set with the reach the target has now')
1164+
assert.deepEqual(copy.carried, ['github', 'composio'], 'nothing has moved yet, so now and set agree')
1165+
1166+
// The set reached the saved state, not only the reply: turning a connector off afterwards must
1167+
// leave the stored set alone and move only what the run would carry now.
1168+
rt.state.bots.m1.connectors = { composio: false }
1169+
const later = (await call('schedules', {})).value.tasks.find(task => task.id === copy.id)
1170+
assert.deepEqual(later.carriedAtSet, ['github', 'composio'], 'the stored set does not move when the reach changes after the copy')
1171+
assert.deepEqual(later.carried, ['github'], 'what the run would carry now is the reach the target has now')
1172+
})

‎docs/subsystems/core-host.md‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -46,7 +46,7 @@ The server side of the patched `ds-bot` core (`core/`): the part of [ds-bot-core
4646
| `core/src/host/face-mentions.js` | Who "@" calls in a face-to-face room (#287): every alias of a participant (`faceAliases`, kept in `shared/remote-label.js` so the bubble chips the same names, #305; bare name, the picker label `<owner>'s Chief` / `<name> · <owner>'s Bot`, `<name> · <owner>`, handle), local and friend's Bots told apart. `faceMentions().handles` is the handle of every Bot a line names (the explicit mention list a sender attaches, #293) and `mentionedByHandle` resolves a received list to my Bots (`known` counts handles the room has). |
4747
| `core/src/shared/look-image.js` | The image a Bot's look may carry (#2646): `safeLookImage` keeps a plain `https?://` URL or a `data:image/(png|jpeg|webp|gif);base64,` string and answers `null` for a value carrying a quote, a paren, a backslash, whitespace or a control character; `cssImageUrl` writes the kept value as `url("…")` for the page-wide mention stylesheet. It is read at the entries — hooks.js `cleanRemoteLook` and remote-chat.js `applyPublishedLook` — and again at that sink (`client/mention-style.js`), so a friend's Bot cannot close the declaration or add a rule; a dropped image draws the colour/mask look. `plugins/social/src/look.js` carries the same test (the same formats, gif included since #2649) and `plugins/social/test/look.test.js` keeps the two in step. Tests: `core/test/mention-style.test.js`. |
4848
| `core/src/host/reach.js` | Per-Bot grants and the owner-policy `reach()` check that hooks.js runs outside the plugin chain (#90); `rt.setGrants`, `rt.hasGrant`, `rt.hasAnyGrant`. A local Bot refused toward a friend's Bot is told that it is not shared with that friend and where to share it (Sharing, #273). `rt.reach` also reads the room a send already belongs to when the caller names none (#948): `sharedRoom` applies only to the `roomOnly` identity — the Bot holds no grant at all and came into that **face-to-face** room by its number (`isCodeJoined`) — and looks for the one such room where the **exact** target is still seated; a Bot that holds a grant, or a room of this home, is judged as it always was and keeps asking for an explicit `roomId`, so a Bot that joined a room by number — a `roomOnly` identity with no person-grant — may line that seat, which is the same allowance `reach()` already applies to an explicit `roomId`; the room itself is named outbound by the transport, never assumed here. A `user-mention` with no named room is also judged under `mentionRoom` (#1126): one live local or inbound group where that Bot is a member and the exact target is still a remote seat, including a seat a group invite admitted (`admittedBy: 'ticket'`). A plain line, `message_bot`, a seat that has left, and a stranger outside every such room stay on the grant rule. Face-to-face stays on `sharedRoom`. Tests: `core/test/reach-policy.test.js`, `core/test/flybot.test.js`. |
49-
| `core/src/host/schedules.js` | Scheduled tasks through DSH's schedule service: list, create, edit, copy, pause/resume, retry and delete for Settings → Scheduled tasks, each task's last run, and moving a Bot's tasks to its fresh part, which rewrites the stored row in place so the task keeps its id, its delivery history and the instant it was already due (#354, #473, #1245, #1287, see **Scheduled tasks: edit, pause, missed runs**, **Scheduled tasks: copy** and **Scheduled tasks: last run and Retry**). Also the `bot_schedules` tool: the Bot-wide list DSH's own `schedule_list` cannot give, group chats' own Sessions included (#628, see **Scheduled tasks: the Bot-wide list**). Tests: `core/test/schedules.test.js`. Tests for team quiet hours, its refusals and the settings write: `core/test/quiet-hours.test.js`; the rule itself is in `core/src/shared/quiet-hours.js` (#1166). The reach the reader set a task with is kept in `state.scheduleCarriedAtSet` and answered as `carriedAtSet` beside `carried` (#2930, see **Scheduled tasks: edit, pause, missed runs**). The `every` selector takes `seconds` (60 to 604800) as well as the older `minutes` form, so a 90-second repeat survives an edit; a value below 60s or above 7 days is refused with the same sentence (#1651). A task name is at most 120 code points (#1895), so 120 emoji is a valid name and one more is refused. The list is a read of the caller's own rows: `schedulesView(actor)` reads each row's Session through the module's own `sourceOf(sessionId, actor)` (the rule #1321 uses for a copy's source and an edit's own Session), so another owner's task stays out and an actor-less call under scoping answers no rows, while an unenforced one-person install answers the whole host; the `schedule-*` writes keep their Session and target gates. A narrowed view also carries `someHidden: true` when a known row was dropped for the caller — the active and the paused loop set it alike — so an empty answer from a narrow caller is not read as a host with nothing scheduled; a row with no known owner hides nothing and sets no flag, and an unenforced install (no actor narrowing anything) never sets it either. |
49+
| `core/src/host/schedules.js` | Scheduled tasks through DSH's schedule service: list, create, edit, copy, pause/resume, retry and delete for Settings → Scheduled tasks, each task's last run, and moving a Bot's tasks to its fresh part, which rewrites the stored row in place so the task keeps its id, its delivery history and the instant it was already due (#354, #473, #1245, #1287, see **Scheduled tasks: edit, pause, missed runs**, **Scheduled tasks: copy** and **Scheduled tasks: last run and Retry**). Also the `bot_schedules` tool: the Bot-wide list DSH's own `schedule_list` cannot give, group chats' own Sessions included (#628, see **Scheduled tasks: the Bot-wide list**). Tests: `core/test/schedules.test.js`. Tests for team quiet hours, its refusals and the settings write: `core/test/quiet-hours.test.js`; the rule itself is in `core/src/shared/quiet-hours.js` (#1166). The reach the reader set a task with is kept in `state.scheduleCarriedAtSet` and answered as `carriedAtSet` beside `carried` (#2930, see **Scheduled tasks: edit, pause, missed runs**). A copy is a new task, so it is set at the copy: its `carriedAtSet` is the target Bot's reach at that moment, never the source's stored set, and the write happens only when `copyRow` answers the new row's id (`#2951`). The `every` selector takes `seconds` (60 to 604800) as well as the older `minutes` form, so a 90-second repeat survives an edit; a value below 60s or above 7 days is refused with the same sentence (#1651). A task name is at most 120 code points (#1895), so 120 emoji is a valid name and one more is refused. The list is a read of the caller's own rows: `schedulesView(actor)` reads each row's Session through the module's own `sourceOf(sessionId, actor)` (the rule #1321 uses for a copy's source and an edit's own Session), so another owner's task stays out and an actor-less call under scoping answers no rows, while an unenforced one-person install answers the whole host; the `schedule-*` writes keep their Session and target gates. A narrowed view also carries `someHidden: true` when a known row was dropped for the caller — the active and the paused loop set it alike — so an empty answer from a narrow caller is not read as a host with nothing scheduled; a row with no known owner hides nothing and sets no flag, and an unenforced install (no actor narrowing anything) never sets it either. |
5050
| `core/src/host/automation-default.js` | Automation tasks on by default (#378): once per profile, `offerBundle` asks DSH's plugin manager to switch on `@deepseek-ai/dsh-experimental-schedule-bundle` and writes the offer to `dsh-defaults.json` next to the team. Tests: `core/test/automation-default.test.js`. |
5151
| `core/src/host/notify.js` | Out-of-app delivery, first half (#355): a transport-agnostic adapter with Slack's `chat.postMessage` shape, one key per reminder so a retried send cannot duplicate, exponential backoff that honours `Retry-After`, three attempts at most, a structural failure not retried, and zero transport calls while the channel is off. Ships `fakeSlack` for tests; nothing calls it until the real Slack transport lands (see **Out-of-app delivery, first half**). Sent and permanently refused keys are each capped at 1 000 process-local entries, oldest dropped first (#2808). Tests: `core/test/notify.test.js`, `core/test/notify-refused-bound.test.js`. |
5252
| `core/src/host/harness.js` | Declarative harness (#874 Option B). Step 0 (#903): `default` names today's prompt / tools / model / step·retry / verifiers (`rt.harness`, `rt.resolveHarness`); behavior-neutral. Step 1: `lite` / `medium` / `heavy` load through the same resolver with distinct declared budgets; `rt.routeHarness` reads one triage label (`harness:lite`, `harness:medium`, `harness:heavy`). `applied` stays false, so the named modules are not rewritten. `harnessPro` checks a config offline against CI, `core/dev/eval`, and `rsi-baseline` and does not call a model. Step 2: `rt.harnessExperience` reads the experience library and does not attach it to a tier. Tree prompt exception: `@flybot/tree` keeps its marked prompt under `plugins/tree` (outside the three mirrors); listed on the harness, injection stays outside this file. Installed in `MODULES` right after `store`. Tests: `core/test/harness.test.js`, `core/test/experience.test.js`. |

‎patches/ds-bot/0001-core-fixes.patch‎

Lines changed: 35 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -7942,7 +7942,7 @@ diff --git a/src/host/schedules.js b/src/host/schedules.js
79427942
}
79437943
if (typeof ctx.inject === 'function') ctx.inject(['schedule'], attach)
79447944
else if (ctx.get?.('schedule') !== undefined) attach({ schedule: ctx.get('schedule'), effect: (execute, label) => ctx.effect(execute, label) })
7945-
@@ -89,63 +89,628 @@ export function install(rt) {
7945+
@@ -89,63 +89,630 @@ export function install(rt) {
79467946
return rt.groupOwners.get(sessionId) ?? rt.pastOwners.get(sessionId)
79477947
}
79487948
const known = owner => owner !== undefined && (owner.botId === undefined ? state.rooms[owner.roomId] !== undefined : state.bots[owner.botId] !== undefined)
@@ -8198,7 +8198,9 @@ diff --git a/src/host/schedules.js b/src/host/schedules.js
81988198
+ // The row write itself. `put`, `get` and the `tasks` row shape are the same private API
81998199
+ // `moveSchedules` documents above; a renamed `put` or `get` throws here and copies nothing.
82008200
+ async function copyRow(fromSession, sourceId, toSession) {
8201-
+ await service.serialize(async () => {
8201+
+ // The id must leave `serialize`: the caller hands it to `noteTargetReach`, which refuses a
8202+
+ // non-string and then saves nothing, so the copy keeps no reach-at-set (#2951).
8203+
+ return await service.serialize(async () => {
82028204
+ const tasks = (await service.getDomain()).table('tasks')
82038205
+ const source = tasks.get(sourceId)
82048206
+ if (source === undefined || source.sessionId !== fromSession) throw invalid('No such task')
@@ -15427,7 +15429,7 @@ diff --git a/test/schedules.test.js b/test/schedules.test.js
1542715429
test('a group chat task lives on the group Session and lists under the group', async (t) => {
1542815430
const schedule = scheduleService()
1542915431
const { ctx, home, call } = setup({ schedule })
15430-
@@ -121,3 +121,931 @@ test('a due reminder reaches a group as its prompts', () => {
15432+
@@ -121,3 +121,961 @@ test('a due reminder reaches a group as its prompts', () => {
1543115433
assert.equal(reminderText(batch), '[Scheduled task] One\n[Scheduled task] Two')
1543215434
assert.equal(reminderText('plain text'), 'plain text')
1543315435
})
@@ -16359,6 +16361,36 @@ diff --git a/test/schedules.test.js b/test/schedules.test.js
1635916361
+ assert.deepEqual(row.carriedAtSet, ['github', 'composio'], 'the reader saved it with both on, so both are what it was set with')
1636016362
+ assert.deepEqual(row.carried, ['github', 'composio'])
1636116363
+})
16364+
+
16365+
+// #2951: a copy is a new task, so it is set at the copy — with the target's reach at that moment.
16366+
+// The copy path hands the new row's id to the same `noteTargetReach` create uses, so when
16367+
+// `copyRow` drops that id the set is never written, `rt.save()` never runs, and the card can never
16368+
+// say the reach moved since it was set.
16369+
+test('#2951: a copy stores the reach the target has when it is copied, so the card can say it moved', async (t) => {
16370+
+ const { rt, call } = await reachSetup(t)
16371+
+ rt.state.bots.w1.connectors = { composio: false }
16372+
+ const made = await call('schedule-create', { target: 'w1', title: 'Briefing', prompt: 'Sum up', when: DAILY })
16373+
+ assert.equal(made.ok, true, JSON.stringify(made))
16374+
+ const [source] = made.value.tasks
16375+
+ assert.deepEqual(source.carriedAtSet, ['github'], 'the source was set while Composio was off')
16376+
+
16377+
+ // The Bot's reach moves before the copy: Composio is on when the copy is made, so the copy is
16378+
+ // set with both — the source's stored set is not the copy's set.
16379+
+ rt.state.bots.w1.connectors = {}
16380+
+ const copied = await call('schedule-create', { target: 'm1', copyFrom: { sessionId: source.sessionId, id: source.id } })
16381+
+ assert.equal(copied.ok, true, JSON.stringify(copied))
16382+
+ const copy = copied.value.tasks.find(task => task.id !== source.id)
16383+
+ assert.equal(copy.botId, 'm1', 'the copy is listed under the target Bot')
16384+
+ assert.deepEqual(copy.carriedAtSet, ['github', 'composio'], 'the copy is set with the reach the target has now')
16385+
+ assert.deepEqual(copy.carried, ['github', 'composio'], 'nothing has moved yet, so now and set agree')
16386+
+
16387+
+ // The set reached the saved state, not only the reply: turning a connector off afterwards must
16388+
+ // leave the stored set alone and move only what the run would carry now.
16389+
+ rt.state.bots.m1.connectors = { composio: false }
16390+
+ const later = (await call('schedules', {})).value.tasks.find(task => task.id === copy.id)
16391+
+ assert.deepEqual(later.carriedAtSet, ['github', 'composio'], 'the stored set does not move when the reach changes after the copy')
16392+
+ assert.deepEqual(later.carried, ['github'], 'what the run would carry now is the reach the target has now')
16393+
+})
1636216394
diff --git a/test/session-identity.test.js b/test/session-identity.test.js
1636316395
--- a/test/session-identity.test.js
1636416396
+++ b/test/session-identity.test.js

0 commit comments

Comments
 (0)