@things-factory/headless-twin 10.1.41 → 10.1.44

package/server/engine/producer-guard.ts

@@ -0,0 +1,64 @@
+/*
+ * **A twin made by one producer is not rebuilt by another.** Pure.
+ *
+ * ── What went wrong (2026-09-24) ─────────────────────────────────────────────
+ * An import's instance id is the adapter's site id (`master.source`). Importing the warehouse connection
+ * `wms-miratek` with site id `miratek` — the same as the plant connection's — landed on the running plant
+ * mirror `miratek`, and `ingestMaster` gave it the warehouse structure as a new revision: 16 places,
+ * 23 equipment, 17 people and 14 assets gone. The row already said who made it (`origin.source` was
+ * `mes-miratek`); nothing asked.
+ *
+ * ── The rule (chief architect ruling, 2026-09-24) ────────────────────────────
+ * Compare producers by identity, not by the whole origin: a reference is kind + source, a template is
+ * kind + templateId. The same import carries more or fewer fields at different call sites (siteId,
+ * spaceId), and a template re-run has new params — those are the same producer re-reading its own twin.
+ *
+ *   both declared, same producer     allowed (resync, re-import, re-run)
+ *   both declared, different         refused, naming the producer that owns it
+ *   prior undeclared, incoming not   refused — nobody can say who made it; delete it first to replace it
+ *   prior declared, incoming not     refused — same reason, the other way
+ *   neither declared                 allowed — the demo seed re-ingesting its own twin at boot. Closes when
+ *                                    the seed declares a template origin.
+ */
+
+export const INSTANCE_TAKEN = 'instance-taken-by-another-source'
+
+export interface ProducerRefusal {
+  code: typeof INSTANCE_TAKEN
+  params: { instance: string; producer: string }
+  message: string
+}
+
+/** Who produced a twin, as one comparable string — or undefined when the origin says nothing usable. */
+export function producerOf(origin: unknown): string | undefined {
+  if (!origin || typeof origin !== 'object') return undefined
+  const o = origin as { kind?: unknown; source?: unknown; templateId?: unknown }
+  if (o.kind === 'reference' && typeof o.source === 'string' && o.source) return `reference:${o.source}`
+  if (o.kind === 'template' && typeof o.templateId === 'string' && o.templateId) return `template:${o.templateId}`
+  /* A kind this guard does not know is still somebody — keep it distinct rather than reading it as none. */
+  if (typeof o.kind === 'string' && o.kind) return `${o.kind}:${String(o.source ?? o.templateId ?? '')}`
+  return undefined
+}
+
+function nameOf(origin: unknown): string {
+  const o = (origin ?? {}) as { source?: unknown; templateId?: unknown }
+  return String(o.source ?? o.templateId ?? '') || 'undeclared'
+}
+
+/** null when `incoming` may rebuild the twin `prior` was made by; otherwise the refusal. */
+export function refuseOverwriteByAnotherProducer(
+  instance: string,
+  priorOrigin: unknown,
+  incomingOrigin: unknown
+): ProducerRefusal | null {
+  const had = producerOf(priorOrigin)
+  const comes = producerOf(incomingOrigin)
+  if (!had && !comes) return null
+  if (had && comes && had === comes) return null
+  const producer = had ? nameOf(priorOrigin) : 'undeclared'
+  return {
+    code: INSTANCE_TAKEN,
+    params: { instance, producer },
+    message: `twin "${instance}" was made by ${producer} — delete it first, or import this site under another id`
+  }
+}

package/server/engine/twin-engine.ts

@@ -25,6 +25,7 @@ import { planLiveContinuity, planWarmStart, unwrapState } from './warm-start.js'
 import { applyDeclarationLayers } from './local-declarations.js'
 import { isOfDomain, parseRuntimeKey, runtimeKey } from './runtime-key.js'
 import { TWIN_STATE_TOPIC, twinStatePayload } from './twin-state-channel.js'
+import { refuseOverwriteByAnotherProducer } from './producer-guard.js'
 import { routeCommand } from './command-routing.js'
 import { TwinInstance } from '../service/twin-instance/twin-instance.js'
 /* 자극의 집은 원본이다(ADR-0029) — 그 행을 읽고 쓴다. */
@@ -1217,6 +1218,7 @@ export class TwinEngine {
       `${plan.itemCount} item(s)`,
       `${plan.equipmentCount} equipment`,
       `${plan.orderCount} open order(s)`,
+      ...(plan.foldedOrderCount ? [`${plan.foldedOrderCount} folded finished order(s)`] : []),
       `${plan.taskCount} task(s)`,
       ...(plan.personCount ? [`${plan.personCount} person(s)`] : []),
       ...(plan.assetCount ? [`${plan.assetCount} asset(s)`] : []),
@@ -3419,6 +3421,19 @@ export class TwinEngine {
      * 대상이 사라졌으면(구조가 바뀌었다) 그 사실을 경고로 낸다 — 갈 곳 없는 선언을 알리지 않고 버리지 않는다.
      */
     const prior = await getRepository(TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId: master.source } })
+    /*
+     * A twin another producer made is not rebuilt here (engine/producer-guard.ts). Refused before anything
+     * below writes — `prior` is saved a few lines on, and refusing after that would leave it half-changed.
+     */
+    if (prior) {
+      const taken = refuseOverwriteByAnotherProducer(master.source, prior.origin, (master as any).origin)
+      if (taken) {
+        const err: any = new Error(taken.message)
+        err.code = taken.code
+        err.params = taken.params
+        throw err
+      }
+    }
     /*
      * 겹이 **둘**이다 — 현장(공간)의 것과 이 트윈의 것. 순서가 규율이다: 현장 먼저, 트윈이 나중.
      * 요금처럼 현장이 정한 수는 그 현장의 트윈 전부가 같이 읽어야 하고, 한 트윈만 다르게 두는 실험은

package/server/engine/warm-start.ts

@@ -66,6 +66,8 @@ export interface WarmStartCounts {
    * progress 만 있는 오더는 남은 수량을 알 수 없어 재계획의 근거가 되지 못한다. 지어내지 않고 뺀다.
    */
   ordersWithoutDemand: number
+  /** Finished orders carried folded (ADR-0092) — 0 when the twin had folded nothing. */
+  foldedOrderCount: number
 }
 
 export type WarmStartPlan =
@@ -86,10 +88,17 @@ interface ObservedState {
   assets?: unknown[]
   tasks?: unknown[]
   orders?: unknown[]
+  foldedOrders?: unknown
   acked?: string[]
   attentionSince?: { id: string; since: string }[]
 }
 
+function foldedTotal(f: { counts: Record<string, Record<string, number>> }): number {
+  let n = 0
+  for (const byStatus of Object.values(f.counts)) for (const c of Object.values(byStatus ?? {})) n += Number(c) || 0
+  return n
+}
+
 /** 관측 상태가 실려 있는지 — 축 하나라도 있으면 상태다(봉투에는 없다). */
 const looksLikeState = (x: any): boolean =>
   !!x && typeof x === 'object' && ['locations', 'items', 'equipment', 'orders', 'tasks', 'persons', 'assets', 'acked'].some(k => k in x)
@@ -146,8 +155,16 @@ export function planWarmStart(state: ObservedState | null | undefined, purpose:
     ? state.attentionSince.filter((x: any): x is { id: string; since: string } => !!x && typeof x.id === 'string' && typeof x.since === 'string')
     : []
 
+  /*
+   * Folded orders (ADR-0092) — their counts are the only record of the finished orders taken out of the hot
+   * list; nothing re-sends them. The seed used to leave them out, so a restart lost every folded count.
+   * Carried as the kernel wrote them; a value without a `counts` object is not a folded side.
+   */
+  const f: any = (state as any).foldedOrders
+  const foldedOrders = f && typeof f === 'object' && f.counts && typeof f.counts === 'object' ? f : undefined
+
   /* 어느 축도 없으면 심을 것이 없다 — 빈 주입으로 로그만 남기지 않는다. */
-  if (!locations.length && !items.length && !equipment.length && !persons.length && !assets.length && !tasks.length && !orders.length && !acked.length && !attentionSince.length) {
+  if (!locations.length && !items.length && !equipment.length && !persons.length && !assets.length && !tasks.length && !orders.length && !foldedOrders && !acked.length && !attentionSince.length) {
     return { action: 'skip', reason: 'no-state' }
   }
 
@@ -167,6 +184,7 @@ export function planWarmStart(state: ObservedState | null | undefined, purpose:
       ...(tasks.length ? { tasks } : {}),
       /* 원값 없는 오더는 넘기지 않는다 — 커널도 걸러 내지만, 넘기지 않으면 세어 둔 수와 어긋날 일이 없다. */
       ...(seedable.length ? { orders: seedable } : {}),
+      ...(foldedOrders ? { foldedOrders } : {}),
       /* 확인 처리는 조건이 사라진 id 가 섞여 있어도 해롭지 않다 — 그 신호가 없으면 표시할 대상이 없다. */
       ...(acked.length ? { acked } : {}),
       /* 조건이 사라진 id 가 섞여 있어도 해롭지 않다 — 커널이 그 신호가 없으면 함께 지운다. */
@@ -178,6 +196,7 @@ export function planWarmStart(state: ObservedState | null | undefined, purpose:
     assetCount: assets.length,
     taskCount: tasks.length,
     orderCount: seedable.length,
+    foldedOrderCount: foldedOrders ? foldedTotal(foldedOrders) : 0,
     ordersWithoutDemand: orders.length - seedable.length,
     ackedCount: acked.length,
     attentionSinceCount: attentionSince.length

package/server/service/reference/reference-resolver.ts

@@ -914,7 +914,7 @@ export class TwinReferenceResolver {
           const at = (adapter.masterSteps?.[lastDone] ?? lastStep) as ReferenceProgress['step']
           emit({ siteId: site.siteId, siteIndex, step: at, done: lastDone, total: stepTotal, failed: true, error: e?.message ?? String(e) })
 
-          failed.push({ siteId: site.siteId, error: e?.message ?? 'failed' })
+          failed.push({ siteId: site.siteId, error: e?.message ?? 'failed', ...(e?.code ? { errorCode: e.code, errorParams: e.params } : {}) })
         }
       }
       // provenance — 이 레퍼런스가 만든 인스턴스 추적(scopeSpec.produced). 삭제 연쇄·상태 동기·네비게이션 근거.

package/server/service/twin-forecast/forecast-metrics.ts

@@ -17,6 +17,27 @@
 
 import { isFlowOrder, isOrderTerminal } from '@operato/ops-contract'
 
+/*
+ * ── Folded orders are counted too (ADR-0092 decision 3, ruling 2026-09-24) ─────────────
+ *
+ * A twin folds finished orders out of its hot list at checkpoint time and keeps only their counts
+ * (`foldedOrders.counts`, kind × terminal status, never trimmed). Counting the hot list alone would drop
+ * `orders` and `shipped` the moment a fold happens — and "the increase since the fork" alone would still
+ * break `twinForecastGapTrend`, whose actual at T+h is read from recovered state: a fold between T and
+ * T+h makes the actual increase negative. So both metrics are cumulative including the folded side, and
+ * an increase is the difference of the same number. Which folded kinds are flow orders is asked of the
+ * contract's `isFlowOrder`, the same as the hot list; `shipped` uses the same word on both sides.
+ */
+function foldedFlowOrders(s: any, status?: string): number {
+  let n = 0
+  for (const [kind, byStatus] of Object.entries((s?.foldedOrders?.counts ?? {}) as Record<string, Record<string, number>>)) {
+    if (!isFlowOrder({ kind })) continue
+    if (status) n += Number(byStatus?.[status]) || 0
+    else for (const c of Object.values(byStatus ?? {})) n += Number(c) || 0
+  }
+  return n
+}
+
 /** 스냅샷 → 수 하나. 값이 없으면 0 이 아니라 **그 지표를 그릴 수 없다**는 뜻이지만, 그래프 계약이
  *  수를 요구하므로 0 을 낸다 — 그래서 에너지 지표는 「없음」이 0 과 헷갈리지 않는 것만 골랐다. */
 export type MetricFn = (s: any) => number
@@ -32,9 +53,9 @@ export const FORECAST_METRICS: Record<string, MetricFn> = {
    * 한 건씩 늘고 백로그는 영영 안 줄어든다 — 예측 그래프가 있지도 않은 일을 그린다. 무엇이 흐름
    * 오더인지는 계약의 `isFlowOrder` 한 곳이 정한다(여기서 `kind` 를 다시 적지 않는다).
    */
-  orders: s => (s?.orders || []).filter(isFlowOrder).length,
+  orders: s => (s?.orders || []).filter(isFlowOrder).length + foldedFlowOrders(s),
   // 이행 지표 — 라이브 예측의 핵심 질문("언제 다 나가나·백로그 언제 풀리나").
-  shipped: s => (s?.orders || []).filter(isFlowOrder).filter((o: any) => o.status === 'shipped').length,
+  shipped: s => (s?.orders || []).filter(isFlowOrder).filter((o: any) => o.status === 'shipped').length + foldedFlowOrders(s, 'shipped'),
   /*
    * ── 백로그는 **「종결인가」**로 묻는다 (2026-09-19) ─────────────────────────
    *

package/test/forecast-metrics.test.ts

@@ -7,7 +7,7 @@
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { FORECAST_METRICS, metricsForKind } from '../dist-server/service/twin-forecast/forecast-metrics.js'
+import { FORECAST_METRICS, metricsForKind } from '../server/service/twin-forecast/forecast-metrics.ts'
 
 test('물류 지표 — 기존 여섯은 그대로 센다', () => {
   const s = {
@@ -112,3 +112,46 @@ test('목록의 모든 키가 실제로 계산 가능하다 — 화면에 뜨는
     }
   }
 })
+
+/*
+ * ★ Folding does not move the count (ADR-0092 decision 3, ruling 2026-09-24).
+ * A twin folds finished orders out of its hot list and keeps kind × status counts. Counting the hot list
+ * alone dropped orders/shipped at every fold, and made the gap trend's actual increase negative.
+ */
+const hot = (orders: any[], foldedOrders?: any) => ({ orders, ...(foldedOrders ? { foldedOrders } : {}) })
+
+test('folding the finished orders leaves orders and shipped where they were', () => {
+  const before = hot([
+    { id: 'o1', kind: 'outbound', status: 'shipped' },
+    { id: 'o2', kind: 'outbound', status: 'cancelled' },
+    { id: 'o3', kind: 'outbound', status: 'picking' },
+    { id: 'r1', kind: 'inbound', status: 'completed' }
+  ])
+  const after = hot([{ id: 'o3', kind: 'outbound', status: 'picking' }], {
+    counts: { outbound: { shipped: 1, cancelled: 1 }, inbound: { completed: 1 } },
+    boundaryMs: 1
+  })
+  for (const m of ['orders', 'shipped', 'backlog'] as const) assert.equal(FORECAST_METRICS[m](after), FORECAST_METRICS[m](before), m)
+  assert.equal(FORECAST_METRICS.orders(after), 3, 'receiving orders are not counted, folded or not')
+})
+
+test('a fold between T and T+h keeps the actual increase from going negative', () => {
+  const atT = hot([{ kind: 'outbound', status: 'shipped' }, { kind: 'outbound', status: 'shipped' }, { kind: 'outbound', status: 'picking' }])
+  /* by T+h: one more shipped, and the three shipped have been folded */
+  const atTh = hot([{ kind: 'outbound', status: 'picking' }], { counts: { outbound: { shipped: 3 } }, boundaryMs: 2 })
+  assert.equal(FORECAST_METRICS.shipped(atTh) - FORECAST_METRICS.shipped(atT), 1)
+  assert.ok(FORECAST_METRICS.orders(atTh) - FORECAST_METRICS.orders(atT) >= 0)
+})
+
+test('a twin with nothing folded counts as before', () => {
+  const s = hot([{ kind: 'outbound', status: 'shipped' }, { status: 'picking' }])
+  assert.equal(FORECAST_METRICS.orders(s), 2)
+  assert.equal(FORECAST_METRICS.shipped(s), 1)
+})
+
+test('a folded order with no kind is a flow order, as it is in the hot list', () => {
+  const folded = hot([], { counts: { '': { shipped: 2 } }, boundaryMs: 1 })
+  const unfolded = hot([{ status: 'shipped' }, { status: 'shipped' }])
+  assert.equal(FORECAST_METRICS.orders(folded), FORECAST_METRICS.orders(unfolded))
+  assert.equal(FORECAST_METRICS.shipped(folded), FORECAST_METRICS.shipped(unfolded))
+})

package/test/producer-guard.test.ts

@@ -0,0 +1,66 @@
+/*
+ * ★ A twin made by one producer is not rebuilt by another (chief architect ruling, 2026-09-24).
+ *
+ * On 09-24 the warehouse connection `wms-miratek`, imported with site id `miratek`, landed on the running
+ * plant mirror `miratek` and replaced its structure. The row already named its producer. These pin the
+ * rule, and the last test pins where it runs: before `ingestMaster` writes anything.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+import { INSTANCE_TAKEN, producerOf, refuseOverwriteByAnotherProducer } from '../server/engine/producer-guard.ts'
+
+const PLANT = { kind: 'reference', source: 'mes-miratek' }
+
+test('a different connection is refused, and the refusal names the connection that made the twin', () => {
+  const r = refuseOverwriteByAnotherProducer('miratek', PLANT, { kind: 'reference', source: 'wms-miratek', siteId: 'miratek' })
+  assert.equal(r?.code, INSTANCE_TAKEN)
+  assert.deepEqual(r?.params, { instance: 'miratek', producer: 'mes-miratek' })
+})
+
+test('the same producer re-reading its own twin passes, whatever else its origin carries', () => {
+  /* Import sites carry { kind, source } at one call and add siteId · spaceId at another (resolver 168 vs 889). */
+  assert.equal(refuseOverwriteByAnotherProducer('miratek', PLANT, { ...PLANT, siteId: 'miratek', spaceId: 'miratek' }), null)
+  /* Resync hands the stored origin back as it is (masterFromOrigin). */
+  assert.equal(refuseOverwriteByAnotherProducer('miratek', { ...PLANT, siteId: 'miratek' }, { ...PLANT, siteId: 'miratek' }), null)
+  /* A template re-run with other knobs is the same template. */
+  assert.equal(
+    refuseOverwriteByAnotherProducer('w1', { kind: 'template', templateId: 'wms-unit-load', params: { racks: 4 } }, { kind: 'template', templateId: 'wms-unit-load', params: { racks: 9 } }),
+    null
+  )
+})
+
+test('a template and a reference are different producers even with the same name', () => {
+  assert.equal(refuseOverwriteByAnotherProducer('x', { kind: 'template', templateId: 'x' }, { kind: 'reference', source: 'x' })?.code, INSTANCE_TAKEN)
+})
+
+test('(a) a twin nobody can name is not rebuilt by a declared producer', () => {
+  const r = refuseOverwriteByAnotherProducer('old', undefined, PLANT)
+  assert.deepEqual(r?.params, { instance: 'old', producer: 'undeclared' })
+})
+
+test('(b) a declared twin is not rebuilt by an undeclared producer', () => {
+  assert.deepEqual(refuseOverwriteByAnotherProducer('miratek', PLANT, undefined)?.params, { instance: 'miratek', producer: 'mes-miratek' })
+})
+
+test('(c) neither declared passes — the demo seed re-ingesting its own twin at boot', () => {
+  assert.equal(refuseOverwriteByAnotherProducer('rosarito-mes', undefined, undefined), null)
+  assert.equal(refuseOverwriteByAnotherProducer('rosarito-mes', {}, { kind: '' }), null)
+})
+
+test('a kind the guard does not know is still somebody, not nobody', () => {
+  assert.notEqual(producerOf({ kind: 'bench', source: 'hatio-yard' }), undefined)
+})
+
+test('ingestMaster refuses before its first write — a refusal after it would leave the twin half-changed', () => {
+  const engine = readFileSync(fileURLToPath(new URL('../server/engine/twin-engine.ts', import.meta.url)), 'utf-8')
+  const at = engine.indexOf('static async ingestMaster(')
+  const body = engine.slice(at, engine.indexOf('\n  static ', at + 10))
+  const guard = body.indexOf('refuseOverwriteByAnotherProducer(')
+  const firstWrite = body.search(/\.save\(|\.update\(|\.insert\(|\.delete\(/)
+  assert.ok(guard > 0, 'ingestMaster no longer asks who made the twin')
+  assert.ok(firstWrite > 0, 'no write found — this check would pass by finding nothing')
+  assert.ok(guard < firstWrite, 'the refusal must come before the first write')
+})

package/test/twin-origin-resync.test.ts

@@ -10,6 +10,12 @@
  *  · 인제스트가 원천을 각인한다 — 원천이 무엇이든 한 자리에
  *  · 원천을 모르는 재프로비전이 **이미 아는 것을 지우지 않는다** — 한 번 지우면 다시 못 읽는다
  *  · 못 읽는 트윈은 **못 읽는다고 말한다** — 짐작으로 아무 원본이나 집지 않는다
+ *
+ * Since 2026-09-24 (chief architect ruling, engine/producer-guard.ts) a re-provision that does not come
+ * from the twin's own producer is **refused** rather than applied: a silent one used to keep the origin
+ * but replace the structure, and a different producer used to replace both — the second is how the
+ * plant mirror `miratek` got the warehouse's structure. The two tests below now pin the refusal, and
+ * that the refused twin's origin and structure are untouched.
  */
 import { test, before, after } from 'node:test'
 import assert from 'node:assert/strict'
@@ -72,26 +78,39 @@ test('인제스트가 원천을 각인한다 — 원천이 무엇이든 한 자
   assert.deepEqual(await originOf(BORN), { kind: 'template', templateId: 'wh-unit-load', params: { bins: 3 } })
 })
 
-test('원천을 모르는 재프로비전이 이미 아는 것을 지우지 않는다 — 한 번 지우면 다시 못 읽는다', async () => {
+const TEMPLATE = { kind: 'template', templateId: 'wh-unit-load', params: { bins: 3 } }
+const locationsOf = async (instanceId: string) =>
+  (await ds.getRepository(TwinInstance).findOne({ where: { instanceId } }))?.model?.locations?.length
+
+test('원천을 모르는 재프로비전은 거절된다 — 원천도 구조도 그대로다', async () => {
   /*
-   * 이 경로는 실제로 있다 — 원천을 모르는 호출자(스크립트·복구·옛 코드)가 같은 트윈을 다시
-   * 인제스트한다. 그때 `origin` 을 덮어 비우면 그 트윈은 **알리지 않고 다시 읽을 수 없게 된다.**
-   * 그런 종류의 손상은 다음번에 다시 읽으려 할 때까지 아무도 모른다.
+   * 이 경로는 실제로 있다 — 원천을 모르는 호출자(스크립트·복구·옛 코드)가 같은 트윈을 다시 인제스트한다.
+   * Its origin used to be kept while the structure was replaced by whatever that caller had. It is refused
+   * now (ruling (b)): the twin's own producer re-reads it; anything else deletes it first.
    */
-  await TwinEngine.ingestMaster(domainId, master(BORN, 5), 'reset')
-  assert.deepEqual(
-    await originOf(BORN),
-    { kind: 'template', templateId: 'wh-unit-load', params: { bins: 3 } },
-    '원천을 말하지 않은 인제스트는 기존 원천을 보존한다'
-  )
+  await assert.rejects(TwinEngine.ingestMaster(domainId, master(BORN, 5), 'reset'), (e: any) => {
+    assert.equal(e.code, 'instance-taken-by-another-source')
+    assert.deepEqual(e.params, { instance: BORN, producer: 'wh-unit-load' })
+    return true
+  })
+  assert.deepEqual(await originOf(BORN), TEMPLATE)
+  assert.equal(await locationsOf(BORN), 4, 'the refused master did not land (dock 1 + bins 3)')
+})
 
-  const inst = await ds.getRepository(TwinInstance).findOne({ where: { instanceId: BORN } })
-  assert.equal(inst.model.locations.length, 6, '구조 자체는 새 마스터로 갱신된다(도크 1 + 빈 5)')
+test('다른 생산자는 거절된다 — 이름을 대고, 원천도 구조도 그대로다', async () => {
+  await assert.rejects(
+    TwinEngine.ingestMaster(domainId, master(BORN, 5, { kind: 'reference', source: 'oracle-wms' }), 'reset'),
+    (e: any) => e.code === 'instance-taken-by-another-source' && e.params?.producer === 'wh-unit-load'
+  )
+  assert.deepEqual(await originOf(BORN), TEMPLATE)
+  assert.equal(await locationsOf(BORN), 4)
 })
 
-test('새 원천을 말하면 갱신된다 — 보존은 침묵에만 적용된다', async () => {
-  await TwinEngine.ingestMaster(domainId, master(BORN, 5, { kind: 'reference', source: 'oracle-wms' }), 'reset')
-  assert.deepEqual(await originOf(BORN), { kind: 'reference', source: 'oracle-wms' })
+test('같은 생산자가 다시 읽으면 지나간다 — 노브가 달라도', async () => {
+  const again = { ...TEMPLATE, params: { bins: 5 } }
+  await TwinEngine.ingestMaster(domainId, master(BORN, 5, again), 'reset')
+  assert.deepEqual(await originOf(BORN), again)
+  assert.equal(await locationsOf(BORN), 6, 'its own template re-run rebuilds it (dock 1 + bins 5)')
 })
 
 test('원천 없이 태어난 트윈은 원천이 없다 — 짐작해 채우지 않는다', async () => {
@@ -106,7 +125,7 @@ test('조회가 다시 읽을 수 있는지를 먼저 답한다 — 못 하는
 
   const born = await q.twinModelSummary(BORN, ctx)
   assert.equal(born.canResync, true)
-  assert.deepEqual(born.origin, { kind: 'reference', source: 'oracle-wms' })
+  assert.deepEqual(born.origin, { ...TEMPLATE, params: { bins: 5 } })
 
   const orphan = await q.twinModelSummary(ORPHAN, ctx)
   assert.equal(orphan.canResync, false, '버튼을 그대로 내면 누를 때마다 실패한다')

package/test/warm-start-seam.test.ts

@@ -142,3 +142,21 @@ test('라이브 상태의 확인 처리가 신호에 반영된다 — 라이브
   const after = withLiveAttentions({ ...state, acked: [signal.id] }).attentions ?? []
   assert.equal(after.find((a: any) => a.id === signal.id)?.state, 'acknowledged', '확인 처리가 라이브 신호에 반영돼야 한다')
 })
+
+/*
+ * ★ Folded orders survive a restart (ADR-0092). Their counts are the only record of the finished orders
+ * taken out of the hot list, and the seed used to leave them out — a restart after a fold lost them all.
+ */
+test('the folded side comes back with the twin — nothing re-sends those counts', () => {
+  const foldedOrders = { counts: { outbound: { shipped: 40, cancelled: 2 }, inbound: { completed: 55 } }, boundaryMs: 1_700_000_000_000 }
+  const { k, plan } = seedKernel({ ...observed([]), foldedOrders } as any)
+  assert.equal(plan.foldedOrderCount, 97)
+  assert.deepEqual((k as any).getSnapshot().foldedOrders?.counts, foldedOrders.counts)
+})
+
+test('a value without counts is not a folded side, and a twin that folded nothing carries none', () => {
+  const junk = planWarmStart({ ...observed([]), foldedOrders: { boundaryMs: 1 } } as any, undefined, true)
+  assert.equal(junk.action === 'hydrate' && 'foldedOrders' in junk.seed, false)
+  const none = planWarmStart(observed([]), undefined, true)
+  assert.equal(none.action === 'hydrate' && none.foldedOrderCount, 0)
+})