@things-factory/headless-twin 10.1.41 → 10.1.45

package/dist-server/service/twin-forecast/forecast-metrics.js

@@ -19,6 +19,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FLOW_METRICS = exports.ENERGY_METRICS = exports.FORECAST_METRICS = void 0;
 exports.metricsForKind = metricsForKind;
 const ops_contract_1 = require("@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, status) {
+    let n = 0;
+    for (const [kind, byStatus] of Object.entries((s?.foldedOrders?.counts ?? {}))) {
+        if (!(0, ops_contract_1.isFlowOrder)({ kind }))
+            continue;
+        if (status)
+            n += Number(byStatus?.[status]) || 0;
+        else
+            for (const c of Object.values(byStatus ?? {}))
+                n += Number(c) || 0;
+    }
+    return n;
+}
 exports.FORECAST_METRICS = {
     items: s => (s?.items || []).length,
     occupancy: s => (s?.locations || []).reduce((a, n) => a + (n.occupancy || 0), 0),
@@ -30,9 +54,9 @@ exports.FORECAST_METRICS = {
      * 한 건씩 늘고 백로그는 영영 안 줄어든다 — 예측 그래프가 있지도 않은 일을 그린다. 무엇이 흐름
      * 오더인지는 계약의 `isFlowOrder` 한 곳이 정한다(여기서 `kind` 를 다시 적지 않는다).
      */
-    orders: s => (s?.orders || []).filter(ops_contract_1.isFlowOrder).length,
+    orders: s => (s?.orders || []).filter(ops_contract_1.isFlowOrder).length + foldedFlowOrders(s),
     // 이행 지표 — 라이브 예측의 핵심 질문("언제 다 나가나·백로그 언제 풀리나").
-    shipped: s => (s?.orders || []).filter(ops_contract_1.isFlowOrder).filter((o) => o.status === 'shipped').length,
+    shipped: s => (s?.orders || []).filter(ops_contract_1.isFlowOrder).filter((o) => o.status === 'shipped').length + foldedFlowOrders(s, 'shipped'),
     /*
      * ── 백로그는 **「종결인가」**로 묻는다 (2026-09-19) ─────────────────────────
      *

package/dist-server/service/twin-forecast/forecast-metrics.js.map

@@ -1 +1 @@
-{"version":3,"file":"forecast-metrics.js","sourceRoot":"","sources":["../../../server/service/twin-forecast/forecast-metrics.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAmEH,wCAEC;AAnED,wDAAoE;AAMvD,QAAA,gBAAgB,GAA6B;IACxD,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM;IACnC,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAS,EAAE,CAAM,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;IAC7F,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM;IACnC;;;;;;OAMG;IACH,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,0BAAW,CAAC,CAAC,MAAM;IACzD,gDAAgD;IAChD,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,0BAAW,CAAC,CAAC,MAAM,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,MAAM;IACrG;;;;;;;;;;;;OAYG;IACH,OAAO,EAAE,CAAC,CAAC,EAAE,CACX,CAAC,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC;SACd,MAAM,CAAC,0BAAW,CAAC;SACnB,MAAM,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,IAAA,8BAAe,EAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,MAAM;IAE7E;;;;OAIG;IACH,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,CAAC,IAAI,CAAC;IAClD;;;OAGG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC;IACtF;;;OAGG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,IAAI,CAAC,CAAC,MAAM;CAChG,CAAA;AAED,gDAAgD;AACnC,QAAA,cAAc,GAAG,CAAC,aAAa,EAAE,QAAQ,EAAE,aAAa,CAAU,CAAA;AAClE,QAAA,YAAY,GAAG,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,CAAU,CAAA;AAEpG;;;;GAIG;AACH,SAAgB,cAAc,CAAC,IAAa;IAC1C,OAAO,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,sBAAc,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,oBAAY,CAAC,CAAA;AACjE,CAAC","sourcesContent":["/*\n * 예측 지표 — **스냅샷에서 수 하나를 뽑는 규칙.**\n *\n * ── 왜 순수 모듈인가 (2026-08-15) ───────────────────────────────────────────\n * 이 표가 리졸버 안에 있어서 시험이 불러올 수 없었다(type-graphql·shell 을 물고 있다). 그런데 여기서\n * 틀리면 예측 그래프 전체가 알리지 않고 다른 것을 그린다 — 오류 없이. 규칙은 시험이 닿는 자리에 둔다.\n *\n * ── 에너지 지표를 더한 이유 ─────────────────────────────────────────────────\n * 예측 화면의 지표가 물류 여섯(재고·점유·작업·오더·출고·백로그)으로 고정돼 있어서, 에너지 트윈을\n * 고르면 **남의 질문에 답하는 그래프**가 떴다. 에너지 트윈에는 재고도 오더도 없으므로 그 값들은\n * 전부 0 이고, 0 은 「없다」가 아니라 「이 트윈의 질문이 아니다」이다.\n *\n * 여기 더한 셋은 **커널이 이미 상태로 들고 있는 것**이다 — 새 계산을 만들지 않았다. 특히 부하 합은\n * 커널이 뿌리 계량기로만 세는데(계층 계량의 이중 계상 방지), 그 규칙을 여기서 다시 쓰면 두 벌이 된다.\n * 그래서 지점을 직접 더하지 않고 **구간 값**을 읽는다.\n */\n\nimport { isFlowOrder, isOrderTerminal } from '@operato/ops-contract'\n\n/** 스냅샷 → 수 하나. 값이 없으면 0 이 아니라 **그 지표를 그릴 수 없다**는 뜻이지만, 그래프 계약이\n *  수를 요구하므로 0 을 낸다 — 그래서 에너지 지표는 「없음」이 0 과 헷갈리지 않는 것만 골랐다. */\nexport type MetricFn = (s: any) => number\n\nexport const FORECAST_METRICS: Record<string, MetricFn> = {\n  items: s => (s?.items || []).length,\n  occupancy: s => (s?.locations || []).reduce((a: number, n: any) => a + (n.occupancy || 0), 0),\n  tasks: s => (s?.tasks || []).length,\n  /*\n   * ── 세는 것은 **흐름 오더**다 (2026-09-19, ADR-0076 보탬 ⑥) ────────────────\n   *\n   * 받는 오더(입고 · 반품 입고)는 도착이 세우고 도착이 이행한다. 그대로 세면 「나간 것」이 받을 때마다\n   * 한 건씩 늘고 백로그는 영영 안 줄어든다 — 예측 그래프가 있지도 않은 일을 그린다. 무엇이 흐름\n   * 오더인지는 계약의 `isFlowOrder` 한 곳이 정한다(여기서 `kind` 를 다시 적지 않는다).\n   */\n  orders: s => (s?.orders || []).filter(isFlowOrder).length,\n  // 이행 지표 — 라이브 예측의 핵심 질문(\"언제 다 나가나·백로그 언제 풀리나\").\n  shipped: s => (s?.orders || []).filter(isFlowOrder).filter((o: any) => o.status === 'shipped').length,\n  /*\n   * ── 백로그는 **「종결인가」**로 묻는다 (2026-09-19) ─────────────────────────\n   *\n   * 낱말 둘(`shipped`·`cancelled`)로 물으면 **원본이 다른 낱말을 쓰는 미러에서 끝난 오더가 영영\n   * 백로그에 남는다.** `status` 는 열린 축이고(표준도 `RequestState` 를 열거하지 않는다) 실 시스템은\n   * `completed`·`FINISHED` 를 쓴다 — 그 트윈의 백로그 곡선은 내려가지 않는다. 종결 판정은 커널이\n   * 한 곳에서 한다(`isOrderTerminal` — 낱말이 아니라 **양**을 1차 근거로 본다).\n   *\n   * `shipped` 한 낱말은 남는다. 그것은 이 커널이 **자기가 쓰는 말**이고(WMS 의 출하 완료), 계약의\n   * 종결 목록(`completed` · `cancelled`)에는 없다. 양을 말하지 않는 스냅샷에서 그 오더가 백로그로\n   * 되돌아오지 않게 둘을 함께 본다 — 빼는 쪽이라 이 셈이 전보다 커지는 일은 없다. 커널의 낱말이\n   * 계약의 종결 목록에 들어오는 날 이 줄이 지워진다(아키텍트에게 올림).\n   */\n  backlog: s =>\n    (s?.orders || [])\n      .filter(isFlowOrder)\n      .filter((o: any) => !isOrderTerminal(o) && o.status !== 'shipped').length,\n\n  /*\n   * ── 에너지 ────────────────────────────────────────────────────────────────\n   * `peakKW` 는 **마감된 구간의 최대**다 — 단조 증가라 지평선 위에서 「최대수요가 어디까지 오르나」로\n   * 읽힌다. 열린 구간은 넣지 않는다(아직 확정이 아니다 — 커널이 지키는 규율을 여기서도 지킨다).\n   */\n  peakKW: s => Number(s?.energy?.peakSince?.kW) || 0,\n  /*\n   * 이번 구간이 이대로 가면 얼마로 마감되나 — 커널이 낸 투영(`mean-so-far`)을 그대로 읽는다.\n   * 우리가 다시 계산하지 않는다: 투영 규칙이 두 벌이 되면 화면과 판정이 다른 말을 한다.\n   */\n  projectedKW: s => Number(s?.energy?.open?.projectedKW ?? s?.energy?.open?.meanKW) || 0,\n  /*\n   * 계약을 넘긴 구간 수 — 「몇 번 넘나」는 요금이 걸린 질문이라 최대치와 따로 본다.\n   * 계약을 모르는 트윈에서는 늘 0 이다(넘김을 판정할 근거가 없다 — 지어내지 않는다).\n   */\n  overWindows: s => (s?.energy?.closed || []).filter((w: any) => w?.overContract === true).length\n}\n\n/** 이 지표가 그 종류의 트윈에서 뜻이 있나 — 화면이 목록을 고를 때 쓴다. */\nexport const ENERGY_METRICS = ['projectedKW', 'peakKW', 'overWindows'] as const\nexport const FLOW_METRICS = ['items', 'occupancy', 'tasks', 'orders', 'shipped', 'backlog'] as const\n\n/**\n * 트윈 종류에 맞는 지표 목록 — **한 곳에서 정한다.**\n *\n * 화면이 각자 목록을 들고 있으면 종류가 늘 때 어느 화면이 뒤처졌는지 알 수 없다.\n */\nexport function metricsForKind(kind?: string): string[] {\n  return kind === 'ems' ? [...ENERGY_METRICS] : [...FLOW_METRICS]\n}\n"]}
+{"version":3,"file":"forecast-metrics.js","sourceRoot":"","sources":["../../../server/service/twin-forecast/forecast-metrics.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * 예측 지표 — **스냅샷에서 수 하나를 뽑는 규칙.**\n *\n * ── 왜 순수 모듈인가 (2026-08-15) ───────────────────────────────────────────\n * 이 표가 리졸버 안에 있어서 시험이 불러올 수 없었다(type-graphql·shell 을 물고 있다). 그런데 여기서\n * 틀리면 예측 그래프 전체가 알리지 않고 다른 것을 그린다 — 오류 없이. 규칙은 시험이 닿는 자리에 둔다.\n *\n * ── 에너지 지표를 더한 이유 ─────────────────────────────────────────────────\n * 예측 화면의 지표가 물류 여섯(재고·점유·작업·오더·출고·백로그)으로 고정돼 있어서, 에너지 트윈을\n * 고르면 **남의 질문에 답하는 그래프**가 떴다. 에너지 트윈에는 재고도 오더도 없으므로 그 값들은\n * 전부 0 이고, 0 은 「없다」가 아니라 「이 트윈의 질문이 아니다」이다.\n *\n * 여기 더한 셋은 **커널이 이미 상태로 들고 있는 것**이다 — 새 계산을 만들지 않았다. 특히 부하 합은\n * 커널이 뿌리 계량기로만 세는데(계층 계량의 이중 계상 방지), 그 규칙을 여기서 다시 쓰면 두 벌이 된다.\n * 그래서 지점을 직접 더하지 않고 **구간 값**을 읽는다.\n */\n\nimport { isFlowOrder, isOrderTerminal } from '@operato/ops-contract'\n\n/*\n * ── Folded orders are counted too (ADR-0092 decision 3, ruling 2026-09-24) ─────────────\n *\n * A twin folds finished orders out of its hot list at checkpoint time and keeps only their counts\n * (`foldedOrders.counts`, kind × terminal status, never trimmed). Counting the hot list alone would drop\n * `orders` and `shipped` the moment a fold happens — and \"the increase since the fork\" alone would still\n * break `twinForecastGapTrend`, whose actual at T+h is read from recovered state: a fold between T and\n * T+h makes the actual increase negative. So both metrics are cumulative including the folded side, and\n * an increase is the difference of the same number. Which folded kinds are flow orders is asked of the\n * contract's `isFlowOrder`, the same as the hot list; `shipped` uses the same word on both sides.\n */\nfunction foldedFlowOrders(s: any, status?: string): number {\n  let n = 0\n  for (const [kind, byStatus] of Object.entries((s?.foldedOrders?.counts ?? {}) as Record<string, Record<string, number>>)) {\n    if (!isFlowOrder({ kind })) continue\n    if (status) n += Number(byStatus?.[status]) || 0\n    else for (const c of Object.values(byStatus ?? {})) n += Number(c) || 0\n  }\n  return n\n}\n\n/** 스냅샷 → 수 하나. 값이 없으면 0 이 아니라 **그 지표를 그릴 수 없다**는 뜻이지만, 그래프 계약이\n *  수를 요구하므로 0 을 낸다 — 그래서 에너지 지표는 「없음」이 0 과 헷갈리지 않는 것만 골랐다. */\nexport type MetricFn = (s: any) => number\n\nexport const FORECAST_METRICS: Record<string, MetricFn> = {\n  items: s => (s?.items || []).length,\n  occupancy: s => (s?.locations || []).reduce((a: number, n: any) => a + (n.occupancy || 0), 0),\n  tasks: s => (s?.tasks || []).length,\n  /*\n   * ── 세는 것은 **흐름 오더**다 (2026-09-19, ADR-0076 보탬 ⑥) ────────────────\n   *\n   * 받는 오더(입고 · 반품 입고)는 도착이 세우고 도착이 이행한다. 그대로 세면 「나간 것」이 받을 때마다\n   * 한 건씩 늘고 백로그는 영영 안 줄어든다 — 예측 그래프가 있지도 않은 일을 그린다. 무엇이 흐름\n   * 오더인지는 계약의 `isFlowOrder` 한 곳이 정한다(여기서 `kind` 를 다시 적지 않는다).\n   */\n  orders: s => (s?.orders || []).filter(isFlowOrder).length + foldedFlowOrders(s),\n  // 이행 지표 — 라이브 예측의 핵심 질문(\"언제 다 나가나·백로그 언제 풀리나\").\n  shipped: s => (s?.orders || []).filter(isFlowOrder).filter((o: any) => o.status === 'shipped').length + foldedFlowOrders(s, 'shipped'),\n  /*\n   * ── 백로그는 **「종결인가」**로 묻는다 (2026-09-19) ─────────────────────────\n   *\n   * 낱말 둘(`shipped`·`cancelled`)로 물으면 **원본이 다른 낱말을 쓰는 미러에서 끝난 오더가 영영\n   * 백로그에 남는다.** `status` 는 열린 축이고(표준도 `RequestState` 를 열거하지 않는다) 실 시스템은\n   * `completed`·`FINISHED` 를 쓴다 — 그 트윈의 백로그 곡선은 내려가지 않는다. 종결 판정은 커널이\n   * 한 곳에서 한다(`isOrderTerminal` — 낱말이 아니라 **양**을 1차 근거로 본다).\n   *\n   * `shipped` 한 낱말은 남는다. 그것은 이 커널이 **자기가 쓰는 말**이고(WMS 의 출하 완료), 계약의\n   * 종결 목록(`completed` · `cancelled`)에는 없다. 양을 말하지 않는 스냅샷에서 그 오더가 백로그로\n   * 되돌아오지 않게 둘을 함께 본다 — 빼는 쪽이라 이 셈이 전보다 커지는 일은 없다. 커널의 낱말이\n   * 계약의 종결 목록에 들어오는 날 이 줄이 지워진다(아키텍트에게 올림).\n   */\n  backlog: s =>\n    (s?.orders || [])\n      .filter(isFlowOrder)\n      .filter((o: any) => !isOrderTerminal(o) && o.status !== 'shipped').length,\n\n  /*\n   * ── 에너지 ────────────────────────────────────────────────────────────────\n   * `peakKW` 는 **마감된 구간의 최대**다 — 단조 증가라 지평선 위에서 「최대수요가 어디까지 오르나」로\n   * 읽힌다. 열린 구간은 넣지 않는다(아직 확정이 아니다 — 커널이 지키는 규율을 여기서도 지킨다).\n   */\n  peakKW: s => Number(s?.energy?.peakSince?.kW) || 0,\n  /*\n   * 이번 구간이 이대로 가면 얼마로 마감되나 — 커널이 낸 투영(`mean-so-far`)을 그대로 읽는다.\n   * 우리가 다시 계산하지 않는다: 투영 규칙이 두 벌이 되면 화면과 판정이 다른 말을 한다.\n   */\n  projectedKW: s => Number(s?.energy?.open?.projectedKW ?? s?.energy?.open?.meanKW) || 0,\n  /*\n   * 계약을 넘긴 구간 수 — 「몇 번 넘나」는 요금이 걸린 질문이라 최대치와 따로 본다.\n   * 계약을 모르는 트윈에서는 늘 0 이다(넘김을 판정할 근거가 없다 — 지어내지 않는다).\n   */\n  overWindows: s => (s?.energy?.closed || []).filter((w: any) => w?.overContract === true).length\n}\n\n/** 이 지표가 그 종류의 트윈에서 뜻이 있나 — 화면이 목록을 고를 때 쓴다. */\nexport const ENERGY_METRICS = ['projectedKW', 'peakKW', 'overWindows'] as const\nexport const FLOW_METRICS = ['items', 'occupancy', 'tasks', 'orders', 'shipped', 'backlog'] as const\n\n/**\n * 트윈 종류에 맞는 지표 목록 — **한 곳에서 정한다.**\n *\n * 화면이 각자 목록을 들고 있으면 종류가 늘 때 어느 화면이 뒤처졌는지 알 수 없다.\n */\nexport function metricsForKind(kind?: string): string[] {\n  return kind === 'ems' ? [...ENERGY_METRICS] : [...FLOW_METRICS]\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/headless-twin",
-  "version": "10.1.41",
+  "version": "10.1.45",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh <heartyoh@hatiolab.com>",
@@ -27,13 +27,13 @@
     "clean:shared": "rm -rf dist-shared tsconfig.shared.tsbuildinfo"
   },
   "dependencies": {
-    "@operato/ops-contract": "^0.9.37",
-    "@operato/twin-kernel": "^0.11.26",
-    "@things-factory/auth-base": "^10.1.40",
-    "@things-factory/cache-service": "^10.1.40",
+    "@operato/ops-contract": "^0.9.38",
+    "@operato/twin-kernel": "^0.11.27",
+    "@things-factory/auth-base": "^10.1.44",
+    "@things-factory/cache-service": "^10.1.44",
     "@things-factory/env": "^10.1.20",
-    "@things-factory/ingest": "^10.1.40",
-    "@things-factory/shell": "^10.1.40"
+    "@things-factory/ingest": "^10.1.44",
+    "@things-factory/shell": "^10.1.44"
   },
-  "gitHead": "4f41243edca4c965bc6992a10fb52d75a58fd3a9"
+  "gitHead": "d72e1fd1285797fcd7839d97a18e31f5bf076ae3"
 }

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-event/twin-event-keys.ts

@@ -1,3 +1,5 @@
+import { bizStepName } from '@operato/ops-contract'
+
 import { twinWarn } from '../../engine/log.js'
 /*
  * 저널 검색 키 추출 — **순수**. 인제스트가 기록할 때 한 번 뽑아 인덱스 가능한 실컬럼으로 승격한다.
@@ -49,11 +51,13 @@ function clip(v: unknown, field: string): string | undefined {
   return s.slice(0, MAX_KEY)
 }
 
-/** CBV bizStep URN 의 끝마디. 없으면 이벤트 타입에서 유추(`epcis.` 접두 제거). */
+/**
+ * bizStep 의 짧은 이름 — 자르는 규칙은 계약의 `bizStepName` 하나다(CBV URN 과 사설 이름공간 URL 둘 다).
+ * 없으면 이벤트 타입에서 유추(`epcis.` 접두 제거).
+ */
 export function bizStepOf(envelope: any): string | undefined {
   const d = envelope?.data ?? envelope ?? {}
-  const tail = String(d.bizStep ?? '').split(':').pop()
-  return tail || String(envelope?.eventType ?? '').replace('epcis.', '') || undefined
+  return bizStepName(d.bizStep) || String(envelope?.eventType ?? '').replace('epcis.', '') || undefined
 }
 
 /**

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-event-keys.test.ts

@@ -63,6 +63,13 @@ test('bizStep 이 없으면 이벤트 타입에서 유추한다 — 운영 델
   assert.equal(bizStepOf({ eventType: 'epcis.AggregationEvent', data: {} }), 'AggregationEvent')
 })
 
+test('a private business step is indexed by its short name, like a CBV one', () => {
+  /* `split(':')` on `https://hatiolab.com/voc/bizstep/consuming` kept `//hatiolab.com/voc/bizstep/consuming` — a journal
+     search for `consuming` found nothing. The rule is the contract's bizStepName. */
+  assert.equal(bizStepOf({ data: { bizStep: 'https://hatiolab.com/voc/bizstep/consuming' } }), 'consuming')
+  assert.equal(bizStepOf({ data: { bizStep: 'urn:epcglobal:cbv:bizstep:shipping' } }), 'shipping')
+})
+
 test('집합 이벤트는 parentID 를, 수량 이벤트는 epcClass 를 품목으로 쓴다', () => {
   assert.equal(epcOf({ data: { parentID: 'urn:epc:id:sscc:0614141.1234567890' } }), 'urn:epc:id:sscc:0614141.1234567890')
   assert.equal(epcOf({ data: { quantityList: [{ epcClass: 'urn:epc:idpat:sgtin:0614141.107346.*', quantity: 40 }] } }), 'urn:epc:idpat:sgtin:0614141.107346.*')

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)
+})