Garry's Opinionated OpenClaw/Hermes Agent Brain
TypeScript
Dream runs no longer write or remove files in a read-only mirror's checkout (#8935)
garrytan535885cef391
diff --git a/docs/architecture/key-files/core-cycle-patterns.md b/docs/architecture/key-files/core-cycle-patterns.mdindex 6c6a65d3b5..532fd495b8 100644--- a/docs/architecture/key-files/core-cycle-patterns.md+++ b/docs/architecture/key-files/core-cycle-patterns.md@@ -21,7 +21,7 @@ Patterns, drift reports and the cycle modules listed after them.- `src/core/cycle/triage-rescue.ts` — THE dream triage gate (`passesTriageGate`) + the verified-segment rescue (`applyTriageRescue`). Rescue fires only for scores in `[floor, threshold)` (floor inclusive; at/above threshold is the plain gate's job) with content_type in the buried-signal allowlist (default mixed/reflection/idea/strategy/people — never routine/technical) and ≥ minSegments of the judge's own segments verifying as normalized transcript substrings (`normForGrounding`, ≥40 chars, deduped by normalized quote — repetition is not more evidence). $0 — no LLM calls; fabricated segments cannot fire it; works on cached verdicts (gate-time only). Fail-closed on every malformed shape (null score, missing/short/non-string segments), never throws. `minSegments: 0` is the kill switch (gate degenerates to the plain threshold). ONE-GATE RULE: `runTriagePass` (report construction — `worth`/`rescued`/telemetry/dry-run), the synthesize fan-out, and `dream retriage` (reconcile-queue cancels + `--audit-rejects` sampling) all read this predicate — a second hand-rolled `score >= threshold` check is how an operator sweep cancels exactly the jobs the rescue admitted. Config: `dream.triage.rescue_floor` / `rescue_min_segments` / `rescue_content_types`. Pinned by `test/cycle-triage-rescue.test.ts` + the rescue suites in `test/cycle-synthesize-triage.test.ts` / `test/dream-retriage.test.ts`. System One S7: a decide verdict (`model` starting with `DECIDE_VERDICT_PREFIX`) is gated against the S7 slot threshold (the optional fifth argument) and never enters the rescue band.-- `src/core/cycle/derived-write-through.ts` — opt-in markdown write-through for generated pages on an unmanaged brain (#5041). `cycle.extract_atoms.write_through` / `cycle.synthesize_concepts.write_through` (off by default; `true`/`1`/`yes`/`on`) make `derivedWriteThrough` return a hook (null when off, managed or dry run): `extract_atoms` writes each item's atoms after the completion flip and removes the files of atoms it retired; `synthesize_concepts` writes through `publishClassicConcept`, which also rewrites a concept that already has a file whatever the key says. Creating the hook writes up to 200 generated pages per run that have no file yet (`source_path` NULL; pending atoms excluded), so enabling the key backfills. `writeDerivedPageThrough` keeps a page database-only when its target is ignored by git or sits in a declared `storage.db_only` directory (`derivedFileTarget`), replaces an existing file only when `replaceableFile` (`facts/file-body-guard.ts`) finds it equal to the page or one of its recent page_versions rows, then calls `writePageThrough` bound to the bytes compared with `inlineOnly` (a generated page stored in segments is skipped `segmented_page`, since the batch rollback compares file strings) and returns its result (`written`, `skipped`, `error`) so `publishClassicConcept` can surface a failed write. #8073: every file write and retired-file unlink is uncommitted (`deferCommit`) and the batch (an item's atoms plus its retired atoms' files, the backfill, or one concept) commits once through the shared-checkout door `commitPathsLocked` (`git/commit-push.ts`) under the source filesystem lock, naming only the batch's paths that exist or are tracked; a directory that is not a Git checkout, or whose checkout lookup fails (`classifyGitCheckout` `unknown`), has nothing to commit. A batch waits for a busy commit lock without blocking the event loop (`acquireCommitLockAsync`, up to 30 s), then takes it synchronously with a 2 s cap. A refused commit is rolled back under the commit lock (2 s wait; still busy, nothing is restored and every file stays in the pending ledger for that writer's commit): it leaves a file whose change HEAD already holds (another writer's locked commit swept it from the ledger) as committed, restores each other file still holding the bytes the batch wrote (`WriteThroughResult.content`; prior bytes, or removed), clears the `source_path` the write bound, settles the restored paths out of the ledger (`settlePending`), and returns a typed `DerivedCommitFailure` (`{code, message, paths, kept}`); the hook then writes nothing more that run and the phases report `details.write_through_failed` with `warn` (`reportDerivedWriteThrough`), while `writeDerivedPageThrough` returns it as `error` so the concept is held. Each page whose change was rolled back or left unwritten is marked in `op_checkpoints` (op `derived-write-retry`, fingerprint `<source>:<slug>`, pruned after the usual 7 days), and the next hook's backfill selects marked pages, live (rewritten, an update of an existing file included) and retired (file removed), clearing each mark once its change commits. Each file written or removed is also recorded in the door's pending ledger (`notePending`) right after the write, so a crash before the commit leaves it for the next `commitPathsLocked` in that checkout to sweep (ledger paths inside the source root that still differ from HEAD; only paths gbrain wrote are recorded). The dream reverse-write (`writeDreamPageFile`, `removeDreamPageFile`, `reverseWriteDreamRefs`) commits the same way: one batch per `reverseWriteDreamRefs` call (committed in a `finally`, so an abort still commits what it wrote) and one per summary write or retired-file removal; a refused commit rolls the files back and returns or pushes a `write_through_failed` hold, which the phases report through their existing `file_holds`. A checkout carrying a canonical owner marker commits through `commitAndPush`'s named-paths-only path (`commitManagedPaths`), and paths git ignores are left uncommitted. Tests: `test/cycle/derived-write-through-commit.test.ts` (with the `derivedWriteSeams.beforeCommit` crash fault point) and `test/cycle/dream-reverse-write-commit.test.ts` (PGLite and Postgres). A retired atom's file is removed under the same filter and comparison, the unlink rechecking the bytes under the source filesystem lock. A file holding an edit the database lacks (or an unindexed file at a backfilled page's path) is left as it is and listed in the hook's `held`, which both phases report as `details.file_holds` (`file_database_drift`) with a `warn` status. Tests: `test/cycle/derived-write-through.test.ts`, `test/pathological/d10-derived-atom-file-overwrite.test.ts`, `test/pathological/d11-derived-retired-atom-unlink.test.ts`. #6982: `writeDreamPageFile` is the dream reverse-write (synthesize, patterns, the cycle summary): nothing with `sync.write_through` off, for an owned url clone or a `storage.db_only` slug; the path is `resolvePageWriteTarget`'s (recorded source_path), falling back to the caller's brainDir layout when the source has no root or its root is missing; the file is replaced only when `replaceableFile` (facts/file-body-guard.ts) finds nothing in it the database lacks and, once the replacement is staged, still holds the compared bytes right before the rename, else the result carries the `file_database_drift` hold. It writes directly (not `writePageThrough`/`atomicWriteFileSync`) because a checkout a subagent tool write claimed through the coordinator refuses those with `writer_coordinator_required`. `reportFileHolds` lists every phase's holds in `details.file_holds` and turns ok into warn.+- `src/core/cycle/derived-write-through.ts` — opt-in markdown write-through for generated pages on an unmanaged brain (#5041). `cycle.extract_atoms.write_through` / `cycle.synthesize_concepts.write_through` (off by default; `true`/`1`/`yes`/`on`) make `derivedWriteThrough` return a hook (null when off, managed or dry run): `extract_atoms` writes each item's atoms after the completion flip and removes the files of atoms it retired; `synthesize_concepts` writes through `publishClassicConcept`, which also rewrites a concept that already has a file whatever the key says. Creating the hook writes up to 200 generated pages per run that have no file yet (`source_path` NULL; pending atoms excluded), so enabling the key backfills. `writeDerivedPageThrough` keeps a page database-only when its target is ignored by git or sits in a declared `storage.db_only` directory (`derivedFileTarget`), replaces an existing file only when `replaceableFile` (`facts/file-body-guard.ts`) finds it equal to the page or one of its recent page_versions rows, then calls `writePageThrough` bound to the bytes compared with `inlineOnly` (a generated page stored in segments is skipped `segmented_page`, since the batch rollback compares file strings) and returns its result (`written`, `skipped`, `error`) so `publishClassicConcept` can surface a failed write. #8073: every file write and retired-file unlink is uncommitted (`deferCommit`) and the batch (an item's atoms plus its retired atoms' files, the backfill, or one concept) commits once through the shared-checkout door `commitPathsLocked` (`git/commit-push.ts`) under the source filesystem lock, naming only the batch's paths that exist or are tracked; a directory that is not a Git checkout, or whose checkout lookup fails (`classifyGitCheckout` `unknown`), has nothing to commit. A batch waits for a busy commit lock without blocking the event loop (`acquireCommitLockAsync`, up to 30 s), then takes it synchronously with a 2 s cap. A refused commit is rolled back under the commit lock (2 s wait; still busy, nothing is restored and every file stays in the pending ledger for that writer's commit): it leaves a file whose change HEAD already holds (another writer's locked commit swept it from the ledger) as committed, restores each other file still holding the bytes the batch wrote (`WriteThroughResult.content`; prior bytes, or removed), clears the `source_path` the write bound, settles the restored paths out of the ledger (`settlePending`), and returns a typed `DerivedCommitFailure` (`{code, message, paths, kept}`); the hook then writes nothing more that run and the phases report `details.write_through_failed` with `warn` (`reportDerivedWriteThrough`), while `writeDerivedPageThrough` returns it as `error` so the concept is held. Each page whose change was rolled back or left unwritten is marked in `op_checkpoints` (op `derived-write-retry`, fingerprint `<source>:<slug>`, pruned after the usual 7 days), and the next hook's backfill selects marked pages, live (rewritten, an update of an existing file included) and retired (file removed), clearing each mark once its change commits. Each file written or removed is also recorded in the door's pending ledger (`notePending`) right after the write, so a crash before the commit leaves it for the next `commitPathsLocked` in that checkout to sweep (ledger paths inside the source root that still differ from HEAD; only paths gbrain wrote are recorded). The dream reverse-write (`writeDreamPageFile`, `removeDreamPageFile`, `reverseWriteDreamRefs`) commits the same way: one batch per `reverseWriteDreamRefs` call (committed in a `finally`, so an abort still commits what it wrote) and one per summary write or retired-file removal; a refused commit rolls the files back and returns or pushes a `write_through_failed` hold, which the phases report through their existing `file_holds`. A checkout carrying a canonical owner marker commits through `commitAndPush`'s named-paths-only path (`commitManagedPaths`), and paths git ignores are left uncommitted. Tests: `test/cycle/derived-write-through-commit.test.ts` (with the `derivedWriteSeams.beforeCommit` crash fault point) and `test/cycle/dream-reverse-write-commit.test.ts` (PGLite and Postgres). A retired atom's file is removed under the same filter and comparison, the unlink rechecking the bytes under the source filesystem lock. A file holding an edit the database lacks (or an unindexed file at a backfilled page's path) is left as it is and listed in the hook's `held`, which both phases report as `details.file_holds` (`file_database_drift`) with a `warn` status. Tests: `test/cycle/derived-write-through.test.ts`, `test/pathological/d10-derived-atom-file-overwrite.test.ts`, `test/pathological/d11-derived-retired-atom-unlink.test.ts`. #6982: `writeDreamPageFile` is the dream reverse-write (synthesize, patterns, the cycle summary): nothing with `sync.write_through` off, for a read-only mirror or an owned url clone (#8935: `sourceMirrorReadOnly`, before any path, so no brainDir fallback either; `removeDreamPageFile` keeps the file) or a `storage.db_only` slug; the path is `resolvePageWriteTarget`'s (recorded source_path), falling back to the caller's brainDir layout when the source has no root or its root is missing; the file is replaced only when `replaceableFile` (facts/file-body-guard.ts) finds nothing in it the database lacks and, once the replacement is staged, still holds the compared bytes right before the rename, else the result carries the `file_database_drift` hold. It writes directly (not `writePageThrough`/`atomicWriteFileSync`) because a checkout a subagent tool write claimed through the coordinator refuses those with `writer_coordinator_required`. `reportFileHolds` lists every phase's holds in `details.file_holds` and turns ok into warn.- `src/core/cycle/concept-publication.ts` — managed `synthesize_concepts` publication: `publishManagedConcept` publishes through `publishMaintenancePage` (a concept with a recorded `source_path` republishes to its file unless a `db_only` tier covers it; new concepts are database-only), and `composeConceptRepublication` keeps an existing concept's facts/takes fences, timeline, tags and other frontmatter, holding the concept (`concept_preservation_hold`) when a fence is duplicated, unbalanced, unparseable or below the timeline sentinel. `replaceConceptProvenanceLinks` banks the concept-provenance edges and retires the edges of atoms that left the group in one transaction (coordinated on a managed brain), only while the concept is at the revision its publication produced (GBRA-161 PR 5, C-4). On an unmanaged brain `publishClassicConcept` writes under the page lock the fence writers take: it re-reads the page, defers (`revision_conflict`) when the narrative changed since synthesis started, another writer owns it, or the page's canonical file holds anything the database lacks (`replaceableFile`: body, fences, timeline, frontmatter, tags, type or title equal to neither the page nor a recent page_versions row; formatting is ignored; this also covers an unindexed file at a new concept's path, and the message names the page with `file_database_drift`), and otherwise composes the new narrative with the database's latest fences, timeline, tags and frontmatter, so a take added during synthesis survives (`test/pathological/d12-concept-stale-fences.test.ts`, `d13-concept-occupied-path.test.ts`). The file write after `importPage` passes the bytes read under the lock as `expectedFileBytes`, so an edit landing during the import is kept and the concept deferred; a failed file write holds the concept (`concept_write_through_failed`) instead of reporting success (W9F item 3, `test/cycle/concept-publication-file-recheck.test.ts`). `stripFenceSections` is the shared narrative view. Tests: `test/cycle/synthesize-concepts-fences.test.ts`. The phase keeps the private-first, provenance, then promotion order; revision races are deferred and holds rep... (line truncated to 2000 chars)- `src/core/cycle/connector-atoms.ts` — the connector atom setting (#5856). `CONNECTOR_ATOM_PAGES_KEY` (`cycle.extract_atoms.connector_pages`, on when unset; `connectorAtomPagesEnabled` treats only false/0/off/no as opted out) gates `CONNECTOR_ATOM_PAGE_TYPES` (`email`, `meeting`) of sources whose `config.kind` is a connector kind (`CONNECTOR_SOURCE_KINDS`). `connectorAtomExclusionSql` returns the `pages p` predicate atom discovery and the backlog count append (empty unless opted out), so the routine cycle, `dream --drain` and autopilot auto-drain extract connector mail and calendar pages under the auto-drain budget until the user opts out. Other page types of a connector source and every checkout-backed page are unaffected. Tests: `test/connector-atom-pages.test.ts`, `test/autopilot-auto-drain-dispatch.test.ts`, and the `atom_drain_default_on` / `atom_drain_opted_out` cases of `test/helpers/managed-connector-job-contract.ts`, run by `test/managed-connector-job-contract.test.ts` and its Postgres twin `test/e2e/managed-connector-job-contract.test.ts`.diff --git a/src/core/cycle/derived-write-through.ts b/src/core/cycle/derived-write-through.tsindex b5b083a1cb..cc14af064c 100644--- a/src/core/cycle/derived-write-through.ts+++ b/src/core/cycle/derived-write-through.ts@@ -35,7 +35,7 @@ import { throwIfAborted } from '../abort-check.ts';import { validateSourceId } from '../utils.ts';import { isDbOnly, loadStorageConfig } from '../storage-config.ts';import { deletePageThrough, isWriteThroughDisabled, resolvePageWriteTarget, writePageThrough, type PageWriteTarget } from '../write-through.ts';-import { urlCloneReadOnly } from '../url-clone.ts';+import { sourceMirrorReadOnly } from '../persistence/mirror-read-only.ts';import { gitChildEnv, literalPathspecs } from '../git-env.ts';import { classifyGitCheckout, type GitCheckoutClass } from '../git-checkout.ts';import { acquireCommitLockAsync, checkoutRoot, commitAndPush, commitPathsLocked, COMMIT_LOCK_ENV, notePending, scopePaths, settlePending } from '../git/commit-push.ts';@@ -410,7 +410,9 @@ async function dreamFileTarget(engine: BrainEngine, brainDir: string, slug: stri* #6982: write the file of a page the dream cycle wrote in the database (a synthesis or patterns output, the cycle* summary) without replacing an edit only the file holds, then commit it (#8073: `commitDerivedChanges`; a refused* commit rolls the file back and returns its `write_through_failed` hold). Nothing is written with `sync.write_through`- * off, for a clone gbrain owns, or for a declared `storage.db_only` slug: the database is the copy of record. The file is+ * off, for a read-only mirror or a clone gbrain owns (#8935: `sourceMirrorReadOnly`, both checked before any path is+ * resolved, so a mirror without a checkout gets no brainDir fallback file either), or for a declared `storage.db_only`+ * slug: the database is the copy of record. The file is* the page's file of record (`resolvePageWriteTarget`: recorded source_path, own-local_path roots); a source with no* usable checkout (no root configured, or the root is missing) keeps the caller's brainDir layout (`<brainDir>/<slug>.md`,* foreign sources under `.sources/<id>/`). The file is replaced only when `replaceableFile` finds nothing in it the@@ -435,7 +437,7 @@ export async function writeDreamPageFile(engine: BrainEngine, brainDir: string,async function writeDreamFile(engine: BrainEngine, brainDir: string, slug: string, sourceId: string,opts: { nativeSourceId: string; markdown: string }): Promise<{ result: DreamPageFileWrite; change?: DerivedFileChange }> {if (await isWriteThroughDisabled(engine)) return { result: { written: false, skipped: 'disabled_by_config' } };- if (await urlCloneReadOnly(engine, sourceId)) return { result: { written: false, skipped: 'url_clone' } };+ if (await sourceMirrorReadOnly(engine, sourceId)) return { result: { written: false, skipped: 'read_only_checkout' } };const target = await dreamFileTarget(engine, brainDir, slug, sourceId, opts.nativeSourceId);if ('skipped' in target) return { result: { written: false, skipped: target.skipped } };try {@@ -462,11 +464,12 @@ async function writeDreamFile(engine: BrainEngine, brainDir: string, slug: strin* GBRA-161 PR 4: remove the file of a dream page a generation retired, resolved the way `writeDreamPageFile` wrote it, only* when the retired page (or one of its versions) holds everything in it; re-read right before the unlink. A file holding* an edit the database lacks stays, with its `file_database_drift` entry returned as `held`. The removal commits- * (#8073); a refused commit puts the file back and returns its `write_through_failed` hold.+ * (#8073); a refused commit puts the file back and returns its `write_through_failed` hold. A read-only mirror or a+ * clone gbrain owns keeps the file (#8935).*/export async function removeDreamPageFile(engine: BrainEngine, brainDir: string, slug: string, sourceId: string,nativeSourceId: string): Promise<{ removed: boolean; held?: string }> {- if (await isWriteThroughDisabled(engine) || await urlCloneReadOnly(engine, sourceId)) return { removed: false };+ if (await isWriteThroughDisabled(engine) || await sourceMirrorReadOnly(engine, sourceId)) return { removed: false };const target = await dreamFileTarget(engine, brainDir, slug, sourceId, nativeSourceId);if ('skipped' in target) return { removed: false };const { filePath } = target;diff --git a/test/cycle/dream-reverse-write-commit.test.ts b/test/cycle/dream-reverse-write-commit.test.tsindex dcefcc42d8..bb546381e1 100644--- a/test/cycle/dream-reverse-write-commit.test.ts+++ b/test/cycle/dream-reverse-write-commit.test.ts@@ -33,6 +33,7 @@ const SOURCE = 'default';const IDEA = 'wiki/originals/ideas/alice-example-idea';const PLAN = 'wiki/originals/ideas/acme-example-plan';const SUMMARY = 'dream-cycle-summaries/2026-09-07';+const MIRROR = 'source-b';interface Brain {engine: BrainEngine;@@ -89,6 +90,8 @@ const lastCommitPaths = (b: Brain) => b.git('show', '--no-renames', '--name-onlyconst dirty = (b: Brain) => b.git('status', '--porcelain', '--untracked-files=all');const filesUnder = (dir: string): string[] => !existsSync(dir) ? [] : readdirSync(dir, { recursive: true, withFileTypes: true }).filter(e => e.isFile() && e.name.endsWith('.md')).map(e => e.name);+const setMirror = (engine: BrainEngine, sourceId: string, readOnly: boolean) =>+ engine.executeRaw(`UPDATE sources SET config = $2::jsonb WHERE id = $1`, [sourceId, JSON.stringify(readOnly ? { mirror_read_only: true } : {})]);const failedHolds = (held: string[], slug: string) => held.filter(h => h.startsWith(`${slug} (write_through_failed`));function refuseCommits(b: Brain): void {@@ -204,5 +207,48 @@ for (const { backend, databaseUrl } of pathologicalArms()) {expect({ written: result.written, held: result.held, file: existsSync(b.path(IDEA)) }).toEqual({ written: 1, held: [], file: true });});}, 180_000);++ test('#8935: a read-only mirror gets no dream file and no commit, and the pages stay in the database', async () => {+ await withBrain(databaseUrl, 'git', async b => {+ await setMirror(b.engine, SOURCE, true);+ const head = b.git('rev-parse', 'HEAD');+ const result = await b.reverseWrite([IDEA, PLAN]);+ const summary = await writeDreamPageFile(b.engine, b.brainDir, SUMMARY, SOURCE,+ { nativeSourceId: SOURCE, markdown: serializePageToMarkdown((await b.engine.getPage(SUMMARY, { sourceId: SOURCE }))!, []) });+ expect({ written: result.written, held: result.held, summary: summary.written, files: filesUnder(b.root), head: b.git('rev-parse', 'HEAD'), dirty: dirty(b) })+ .toEqual({ written: 0, held: [], summary: false, files: ['README.md'], head, dirty: '' });+ expect((await b.engine.getPage(PLAN, { sourceId: SOURCE }))?.title).toBe('Acme Example plan');+ });+ }, 180_000);++ test('#8935: a read-only mirror keeps a tracked dream file as it is (no rewrite, no removal) until the source is writable again', async () => {+ await withBrain(databaseUrl, 'git', async b => {+ await b.reverseWrite([IDEA]);+ const tracked = readFileSync(b.path(IDEA), 'utf8');+ await importFromContent(b.engine, IDEA, page('Alice Example idea', 'A revision the dream made in the database.'), { noEmbed: true, sourceId: SOURCE });+ await setMirror(b.engine, SOURCE, true);+ const head = b.git('rev-parse', 'HEAD');+ const rewrite = await b.reverseWrite([IDEA]);+ const removal = await removeDreamPageFile(b.engine, b.brainDir, IDEA, SOURCE, SOURCE);+ expect({ written: rewrite.written, held: rewrite.held, removed: removal.removed, bytes: existsSync(b.path(IDEA)) ? readFileSync(b.path(IDEA), 'utf8') : null, head: b.git('rev-parse', 'HEAD'), dirty: dirty(b) })+ .toEqual({ written: 0, held: [], removed: false, bytes: tracked, head, dirty: '' });+ await setMirror(b.engine, SOURCE, false);+ expect({ written: (await b.reverseWrite([IDEA])).written, revised: readFileSync(b.path(IDEA), 'utf8').includes('A revision the dream made in the database.'), dirty: dirty(b) })+ .toEqual({ written: 1, revised: true, dirty: '' });+ });+ }, 180_000);++ test('#8935: a read-only mirror with no checkout gets nothing in the brain directory fallback, while a writable source in the same pass publishes', async () => {+ await withBrain(databaseUrl, 'git', async b => {+ await b.engine.executeRaw(`INSERT INTO sources (id, name, config) VALUES ($1, $1, '{"mirror_read_only": true}'::jsonb)`, [MIRROR]);+ await importFromContent(b.engine, IDEA, page('Alice Example mirror idea', 'Kept in the database only.'), { noEmbed: true, sourceId: MIRROR });+ const held: string[] = [];+ const written = await reverseWriteDreamRefs(b.engine, b.brainDir, [{ slug: IDEA, source_id: MIRROR }, { slug: PLAN, source_id: SOURCE }],+ { phase: 'synthesize', nativeSourceId: SOURCE, render: (p, tags) => serializePageToMarkdown(p, tags), held });+ expect({ written, held, fallback: existsSync(join(b.root, '.sources', MIRROR)), plan: existsSync(b.path(PLAN)), dirty: dirty(b) })+ .toEqual({ written: 1, held: [], fallback: false, plan: true, dirty: '' });+ expect((await b.engine.getPage(IDEA, { sourceId: MIRROR }))?.title).toBe('Alice Example mirror idea');+ });+ }, 180_000);});}