@things-factory/headless-twin 10.0.18 → 10.1.0

package/dist-server/service/actuation/rule-loop.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_PERIOD_MS = void 0;
+exports.startActuationRuleLoop = startActuationRuleLoop;
+exports.stopActuationRuleLoop = stopActuationRuleLoop;
+/*
+ * 규칙을 주기로 돌리는 타이머 하나.
+ *
+ * ── 왜 커널 틱이 아닌가 ──────────────────────────────────────────────────
+ * `tickGuarded` 는 예외가 나면 **그 트윈을 멈춘다.** 규칙 하나가 잘못됐다고 공장이 멈추면 안 된다.
+ * 그리고 굶김 감시가 느린 틱 셋에 트윈을 내리는데, 규칙은 DB 를 두 번 건드리므로 그 감시에 걸린다.
+ *
+ * ── 왜 이 간격인가 ───────────────────────────────────────────────────────
+ * 규칙이 보는 것은 **오래 이어진 조건**이다. 「병목이 세 시간째」를 1초마다 다시 물을 이유가 없다.
+ * 짧게 잡으면 얻는 것 없이 DB 를 두 번씩 더 친다.
+ *
+ * ── 겹쳐 돌지 않는다 ─────────────────────────────────────────────────────
+ * 한 바퀴가 간격보다 오래 걸리면 다음 발화가 겹친다. 겹치면 두 바퀴가 같은 근거 집합을 읽고 **같은
+ * 조치를 두 벌 낸다** — 중복을 막는 장치가 그 순간 통과된다.
+ */
+const ops_contract_1 = require("@operato/ops-contract");
+const log_js_1 = require("../../engine/log.js");
+const twin_engine_js_1 = require("../../engine/twin-engine.js");
+const reference_adapter_js_1 = require("../reference/reference-adapter.js");
+const actuation_routing_js_1 = require("../reference/actuation-routing.js");
+const sweep_dispatch_js_1 = require("./sweep-dispatch.js");
+const catch_up_effects_js_1 = require("./catch-up-effects.js");
+const command_store_js_1 = require("./command-store.js");
+const rule_runner_js_1 = require("./rule-runner.js");
+const rule_wiring_js_1 = require("./rule-wiring.js");
+/** 몇 초마다 도나. 오래 이어진 조건을 보는 일이라 촘촘할 이유가 없다. */
+exports.RULE_PERIOD_MS = 30_000;
+let timer;
+let running = false;
+/** 주기를 세운다 — 두 번 불러도 하나만 선다. */
+function startActuationRuleLoop(periodMs = exports.RULE_PERIOD_MS) {
+    if (timer)
+        return;
+    timer = setInterval(() => {
+        /* 앞 바퀴가 아직 돈다 — 겹치면 같은 조치를 두 벌 낸다. 건너뛰는 것이 맞다. */
+        if (running)
+            return;
+        running = true;
+        tickRules()
+            .catch(err => (0, log_js_1.twinError)(`[twin-rule] 규칙 주기가 실패했다 — ${err?.message ?? err}`))
+            .finally(() => {
+            running = false;
+        });
+    }, periodMs);
+    /* 이 타이머 때문에 프로세스가 안 죽지 않게. */
+    if (typeof timer?.unref === 'function')
+        timer.unref();
+}
+function stopActuationRuleLoop() {
+    if (!timer)
+        return;
+    clearInterval(timer);
+    timer = undefined;
+}
+/**
+ * 일꾼이 한 바퀴에 무엇을 했나 — **바뀌었을 때만** 적는다.
+ *
+ * ── 왜 필요한가 (2026-09-04) ────────────────────────────────────────────────
+ * 처음에 보고를 받고 버렸다. 그러니 대기 줄에 조치가 앉아 있는데 아무 일도 안 일어날 때
+ * **이유를 알 길이 없었다** — 실제로 그 상태를 만나 30분을 뒤졌다. 집지 않는 것은 대개 옳은
+ * 판단이지만, 옳은 판단도 보이지 않으면 결함과 구별되지 않는다.
+ *
+ * ── 왜 바뀌었을 때만인가 ────────────────────────────────────────────────────
+ * 30초마다 같은 줄을 적으면 하루 2,880줄이고 그 사이의 진짜 변화가 묻힌다. 대기 줄의 모양이
+ * 그대로면 새로 말할 것이 없다 — `noteBlocked` 에서 지킨 것과 같은 규율이다.
+ */
+const lastSweep = new Map();
+function noteSweep(domainId, report) {
+    if (!report.seen) {
+        lastSweep.delete(domainId);
+        return;
+    }
+    const skips = Object.entries(report.skipped)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([why, n]) => `${why} ${n}`)
+        .join(' · ');
+    const line = `${report.seen}건 대기 · 넘김 ${report.dispatched}${skips ? ` · ${skips}` : ''}`;
+    if (lastSweep.get(domainId) === line)
+        return;
+    lastSweep.set(domainId, line);
+    (0, log_js_1.twinLog)(`[twin-sweep] ${line}`);
+}
+async function tickRules() {
+    /*
+     * ── 유입 창을 먼저 굴린다 (2026-09-05) ─────────────────────────────────────
+     * 창이 닫히는 이유는 **시간이 지난 것**이다. 그런데 예전에는 「다음 사건이 왔을 때」와 「누가
+     * 물어볼 때」만 굴렀다 — 둘 다 안 올 수 있다.
+     *
+     * 그래서 사실이 드문 트윈은 표에 아무것도 안 남았다. 실측: 46건이 62분에 흩어져 온 트윈의 창이
+     * 1개, 사실 11건뿐인 트윈의 창이 48개 — **사실 수와 창 수가 거꾸로**였다. 창을 만든 것이 유입이
+     * 아니라 누가 물어본 것이었기 때문이다.
+     *
+     * **아무도 안 보는 트윈일수록 기록이 없었다.** 사실이 조용히 사라지는 것을 잡으려는 장부가 정확히
+     * 그 반대로 돌고 있었다(137봉투가 장부 없이 지나갔다 — 인티그레이션 레인 실측).
+     *
+     * 소유한 트윈이 없어도 굴린다 — 장부는 프로세스가 사는 동안 이어지고, 규칙을 돌 트윈이 없다는
+     * 것과 기록할 창이 없다는 것은 다른 사실이다.
+     */
+    const rolled = twin_engine_js_1.TwinEngine.rollAllIngestWindows();
+    if (rolled)
+        (0, log_js_1.twinLog)(`[twin-ingest] 창 ${rolled}개를 닫아 적었다`);
+    const owned = twin_engine_js_1.TwinEngine.ownedTwins();
+    if (!owned.length)
+        return;
+    /*
+     * 트랜잭션을 넘기지 않는다 — 여러 트윈을 돌고, 한 트윈이 실패해도 앞의 트윈이 낸 것은 남아야 한다.
+     * 한 덩어리로 묶으면 마지막 트윈의 실패가 앞의 결과를 전부 물린다.
+     */
+    /*
+     * **놓친 보고를 함께 backfill 한다** — 관측 → 조치의 반대 방향이다.
+     *
+     * 같은 주기를 쓰는 이유는 값이다: 둘 다 몇 초마다 볼 일이고, 타이머를 둘 두면 내리고 세울 자리가
+     * 둘이 된다. 다만 **서로 막지 않는다** — 규칙이 터져도 backfill 은 돌아야 한다. 조치를 못 내는 것과
+     * 나간 조치의 결과를 모르는 것은 다른 사고다.
+     */
+    for (const domainId of new Set(owned.map(t => t.domainId))) {
+        await (0, catch_up_effects_js_1.catchUpEffects)(domainId, (0, command_store_js_1.databaseCommandStore)());
+        /*
+         * **넘길 차례를 기다리는 것들도 함께 줍는다** — 승인만 되고 안 나간 것, 실패해서 다시 해 볼 것.
+         *
+         * 정상 경로는 승인 직후에 이미 끝난다(§`dispatchAfterApproval`, 실측 282ms). 이 자리는 **그
+         * 사이에 프로세스가 죽은 경우**와 재시도만 본다. 그래서 30초로 충분하고 아무도 안 기다린다.
+         */
+        const swept = await (0, sweep_dispatch_js_1.sweepPendingDispatch)(domainId, {
+            store: (0, command_store_js_1.databaseCommandStore)(),
+            actuate: command => (0, actuation_routing_js_1.routeActuation)(domainId, command.instanceId, command),
+            idempotent: async (instanceId) => {
+                const target = await (0, actuation_routing_js_1.actuationTargetOf)(domainId, instanceId).catch(() => undefined);
+                const type = target?.adapterType;
+                return type ? (0, reference_adapter_js_1.capabilitiesOf)((0, reference_adapter_js_1.getAdapter)(type)).includes('idempotent-actuation') : false;
+            },
+            localReadiness: async (instanceId) => {
+                const r = await (0, actuation_routing_js_1.actuationReadinessOf)(domainId, instanceId).catch(() => undefined);
+                /* 원격으로 물어 본 답은 쓰지 않는다 — 이 자리는 저쪽을 건드리지 않는 것이 규약이다. */
+                return r && r.checked === 'local' ? r : undefined;
+            }
+        });
+        noteSweep(domainId, swept);
+    }
+    await (0, rule_runner_js_1.runRulesOnce)({
+        ownedTwins: () => owned,
+        rulesOf: rule_wiring_js_1.rulesOf,
+        attentionsOf: rule_wiring_js_1.attentionsOf,
+        modeOf: rule_wiring_js_1.modeOf,
+        store: (0, command_store_js_1.databaseCommandStore)(),
+        specs: ops_contract_1.MES_COMMANDS,
+        nowMs: () => Date.now(),
+        noteRun: rule_wiring_js_1.noteRun
+    });
+}
+//# sourceMappingURL=rule-loop.js.map

package/dist-server/service/actuation/rule-loop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-loop.js","sourceRoot":"","sources":["../../../server/service/actuation/rule-loop.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * 규칙을 주기로 돌리는 타이머 하나.\n *\n * ── 왜 커널 틱이 아닌가 ──────────────────────────────────────────────────\n * `tickGuarded` 는 예외가 나면 **그 트윈을 멈춘다.** 규칙 하나가 잘못됐다고 공장이 멈추면 안 된다.\n * 그리고 굶김 감시가 느린 틱 셋에 트윈을 내리는데, 규칙은 DB 를 두 번 건드리므로 그 감시에 걸린다.\n *\n * ── 왜 이 간격인가 ───────────────────────────────────────────────────────\n * 규칙이 보는 것은 **오래 이어진 조건**이다. 「병목이 세 시간째」를 1초마다 다시 물을 이유가 없다.\n * 짧게 잡으면 얻는 것 없이 DB 를 두 번씩 더 친다.\n *\n * ── 겹쳐 돌지 않는다 ─────────────────────────────────────────────────────\n * 한 바퀴가 간격보다 오래 걸리면 다음 발화가 겹친다. 겹치면 두 바퀴가 같은 근거 집합을 읽고 **같은\n * 조치를 두 벌 낸다** — 중복을 막는 장치가 그 순간 통과된다.\n */\nimport { MES_COMMANDS } from '@operato/ops-contract'\n\nimport { twinError, twinLog } from '../../engine/log.js'\nimport { TwinEngine } from '../../engine/twin-engine.js'\n\nimport { capabilitiesOf, getAdapter } from '../reference/reference-adapter.js'\nimport { actuationReadinessOf, actuationTargetOf, routeActuation } from '../reference/actuation-routing.js'\nimport { sweepPendingDispatch, type SweepReport } from './sweep-dispatch.js'\nimport { catchUpEffects } from './catch-up-effects.js'\nimport { databaseCommandStore } from './command-store.js'\nimport { runRulesOnce } from './rule-runner.js'\nimport { attentionsOf, modeOf, noteRun, rulesOf } from './rule-wiring.js'\n\n/** 몇 초마다 도나. 오래 이어진 조건을 보는 일이라 촘촘할 이유가 없다. */\nexport const RULE_PERIOD_MS = 30_000\n\nlet timer: any\nlet running = false\n\n/** 주기를 세운다 — 두 번 불러도 하나만 선다. */\nexport function startActuationRuleLoop(periodMs = RULE_PERIOD_MS): void {\n  if (timer) return\n\n  timer = setInterval(() => {\n    /* 앞 바퀴가 아직 돈다 — 겹치면 같은 조치를 두 벌 낸다. 건너뛰는 것이 맞다. */\n    if (running) return\n    running = true\n\n    tickRules()\n      .catch(err => twinError(`[twin-rule] 규칙 주기가 실패했다 — ${err?.message ?? err}`))\n      .finally(() => {\n        running = false\n      })\n  }, periodMs)\n\n  /* 이 타이머 때문에 프로세스가 안 죽지 않게. */\n  if (typeof timer?.unref === 'function') timer.unref()\n}\n\nexport function stopActuationRuleLoop(): void {\n  if (!timer) return\n  clearInterval(timer)\n  timer = undefined\n}\n\n/**\n * 일꾼이 한 바퀴에 무엇을 했나 — **바뀌었을 때만** 적는다.\n *\n * ── 왜 필요한가 (2026-09-04) ────────────────────────────────────────────────\n * 처음에 보고를 받고 버렸다. 그러니 대기 줄에 조치가 앉아 있는데 아무 일도 안 일어날 때\n * **이유를 알 길이 없었다** — 실제로 그 상태를 만나 30분을 뒤졌다. 집지 않는 것은 대개 옳은\n * 판단이지만, 옳은 판단도 보이지 않으면 결함과 구별되지 않는다.\n *\n * ── 왜 바뀌었을 때만인가 ────────────────────────────────────────────────────\n * 30초마다 같은 줄을 적으면 하루 2,880줄이고 그 사이의 진짜 변화가 묻힌다. 대기 줄의 모양이\n * 그대로면 새로 말할 것이 없다 — `noteBlocked` 에서 지킨 것과 같은 규율이다.\n */\nconst lastSweep = new Map<string, string>()\n\nfunction noteSweep(domainId: string, report: SweepReport): void {\n  if (!report.seen) {\n    lastSweep.delete(domainId)\n    return\n  }\n\n  const skips = Object.entries(report.skipped)\n    .sort(([a], [b]) => a.localeCompare(b))\n    .map(([why, n]) => `${why} ${n}`)\n    .join(' · ')\n  const line = `${report.seen}건 대기 · 넘김 ${report.dispatched}${skips ? ` · ${skips}` : ''}`\n\n  if (lastSweep.get(domainId) === line) return\n  lastSweep.set(domainId, line)\n  twinLog(`[twin-sweep] ${line}`)\n}\n\nasync function tickRules(): Promise<void> {\n  /*\n   * ── 유입 창을 먼저 굴린다 (2026-09-05) ─────────────────────────────────────\n   * 창이 닫히는 이유는 **시간이 지난 것**이다. 그런데 예전에는 「다음 사건이 왔을 때」와 「누가\n   * 물어볼 때」만 굴렀다 — 둘 다 안 올 수 있다.\n   *\n   * 그래서 사실이 드문 트윈은 표에 아무것도 안 남았다. 실측: 46건이 62분에 흩어져 온 트윈의 창이\n   * 1개, 사실 11건뿐인 트윈의 창이 48개 — **사실 수와 창 수가 거꾸로**였다. 창을 만든 것이 유입이\n   * 아니라 누가 물어본 것이었기 때문이다.\n   *\n   * **아무도 안 보는 트윈일수록 기록이 없었다.** 사실이 조용히 사라지는 것을 잡으려는 장부가 정확히\n   * 그 반대로 돌고 있었다(137봉투가 장부 없이 지나갔다 — 인티그레이션 레인 실측).\n   *\n   * 소유한 트윈이 없어도 굴린다 — 장부는 프로세스가 사는 동안 이어지고, 규칙을 돌 트윈이 없다는\n   * 것과 기록할 창이 없다는 것은 다른 사실이다.\n   */\n  const rolled = TwinEngine.rollAllIngestWindows()\n  if (rolled) twinLog(`[twin-ingest] 창 ${rolled}개를 닫아 적었다`)\n\n  const owned = TwinEngine.ownedTwins()\n  if (!owned.length) return\n\n  /*\n   * 트랜잭션을 넘기지 않는다 — 여러 트윈을 돌고, 한 트윈이 실패해도 앞의 트윈이 낸 것은 남아야 한다.\n   * 한 덩어리로 묶으면 마지막 트윈의 실패가 앞의 결과를 전부 물린다.\n   */\n  /*\n   * **놓친 보고를 함께 backfill 한다** — 관측 → 조치의 반대 방향이다.\n   *\n   * 같은 주기를 쓰는 이유는 값이다: 둘 다 몇 초마다 볼 일이고, 타이머를 둘 두면 내리고 세울 자리가\n   * 둘이 된다. 다만 **서로 막지 않는다** — 규칙이 터져도 backfill 은 돌아야 한다. 조치를 못 내는 것과\n   * 나간 조치의 결과를 모르는 것은 다른 사고다.\n   */\n  for (const domainId of new Set(owned.map(t => t.domainId))) {\n    await catchUpEffects(domainId, databaseCommandStore())\n    /*\n     * **넘길 차례를 기다리는 것들도 함께 줍는다** — 승인만 되고 안 나간 것, 실패해서 다시 해 볼 것.\n     *\n     * 정상 경로는 승인 직후에 이미 끝난다(§`dispatchAfterApproval`, 실측 282ms). 이 자리는 **그\n     * 사이에 프로세스가 죽은 경우**와 재시도만 본다. 그래서 30초로 충분하고 아무도 안 기다린다.\n     */\n    const swept = await sweepPendingDispatch(domainId, {\n      store: databaseCommandStore(),\n      actuate: command => routeActuation(domainId, command.instanceId, command),\n      idempotent: async instanceId => {\n        const target = await actuationTargetOf(domainId, instanceId).catch(() => undefined)\n        const type = (target as any)?.adapterType\n        return type ? capabilitiesOf(getAdapter(type)).includes('idempotent-actuation') : false\n      },\n      localReadiness: async instanceId => {\n        const r = await actuationReadinessOf(domainId, instanceId).catch(() => undefined)\n        /* 원격으로 물어 본 답은 쓰지 않는다 — 이 자리는 저쪽을 건드리지 않는 것이 규약이다. */\n        return r && (r as any).checked === 'local' ? (r as any) : undefined\n      }\n    })\n    noteSweep(domainId, swept)\n  }\n\n  await runRulesOnce({\n    ownedTwins: () => owned,\n    rulesOf,\n    attentionsOf,\n    modeOf,\n    store: databaseCommandStore(),\n    specs: MES_COMMANDS,\n    nowMs: () => Date.now(),\n    noteRun\n  })\n}\n"]}

package/dist-server/service/actuation/rule-runner.d.ts

@@ -0,0 +1,52 @@
+import type { CommandTypeSpec } from '@operato/ops-contract';
+import { type CommandStore } from './command-dispatcher.js';
+import { type ActuationRuleSpec, type AttentionLike, type RuleSkip } from './rule-evaluate.js';
+/** 이 프로세스가 든 트윈 하나. */
+export interface OwnedTwin {
+    domainId: string;
+    instanceId: string;
+}
+/** 한 트윈을 돌고 나서 남는 사실. */
+export interface TwinRunReport {
+    domainId: string;
+    instanceId: string;
+    /** 실제로 적힌 커맨드 수. */
+    proposed: number;
+    /** 규칙마다 몇 개를 냈나 — 규칙 행에 누계를 적으려면 나누어 세어야 한다. */
+    proposedByRule: Record<string, number>;
+    /** 왜 안 올렸나 — 규칙이 조용히 안 도는 것과 조건이 없어서 안 내는 것을 구별한다. */
+    skips: RuleSkip[];
+    /** 상한에 닿아 두고 온 수. */
+    withheld?: number;
+    /** 이 트윈을 아예 못 돌았으면 그 이유. */
+    failed?: string;
+}
+/** 밖에서 받는 것들 — 저장소도 엔진도 시계도 인자다. 그래야 시험이 재기동과 상한을 걸을 수 있다. */
+export interface RuleRunnerDeps {
+    /** 이 프로세스가 든 트윈들. 남의 프로세스가 든 트윈은 그쪽이 돈다. */
+    ownedTwins(): OwnedTwin[];
+    /** 이 트윈에 걸린 규칙 — 없으면 스냅샷을 읽지 않는다. */
+    rulesOf(twin: OwnedTwin): Promise<ActuationRuleSpec[]>;
+    /** 지금 서 있는 주의들. */
+    attentionsOf(twin: OwnedTwin): AttentionLike[] | undefined;
+    /**
+     * 이 트윈이 **무엇을 비추고 있나** — 관측(`live`)인가 가정(`sim`)인가.
+     *
+     * 이 값이 없거나 `live` 가 아니면 조치를 내지 않는다(§`runOneTwin`). 모름을 통과로 읽지 않는다.
+     */
+    modeOf(twin: OwnedTwin): 'live' | 'sim' | undefined;
+    /** 커맨드가 사는 자리. */
+    store: CommandStore;
+    /** 선언된 조치 종류 — 없는 종류를 가리키는 규칙은 판정이 걸러 낸다. */
+    specs: readonly CommandTypeSpec[];
+    nowMs(): number;
+    /** 돈 결과를 규칙 행에 남긴다 — 화면이 「이 규칙이 돌고 있나」를 말할 수 있게. */
+    noteRun?(twin: OwnedTwin, report: TwinRunReport): Promise<void>;
+    maxPerRun?: number;
+}
+/**
+ * 한 바퀴 돈다 — **한 트윈이 실패해도 나머지는 돈다.**
+ *
+ * 트윈 하나의 규칙이 잘못됐다고 다른 공장의 규칙이 멈추면, 고치는 동안 전체가 멈춘 셈이 된다.
+ */
+export declare function runRulesOnce(deps: RuleRunnerDeps): Promise<TwinRunReport[]>;

package/dist-server/service/actuation/rule-runner.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRulesOnce = runRulesOnce;
+const log_js_1 = require("../../engine/log.js");
+const command_dispatcher_js_1 = require("./command-dispatcher.js");
+const rule_evaluate_js_1 = require("./rule-evaluate.js");
+/**
+ * 한 바퀴 돈다 — **한 트윈이 실패해도 나머지는 돈다.**
+ *
+ * 트윈 하나의 규칙이 잘못됐다고 다른 공장의 규칙이 멈추면, 고치는 동안 전체가 멈춘 셈이 된다.
+ */
+async function runRulesOnce(deps) {
+    const out = [];
+    for (const twin of deps.ownedTwins()) {
+        const report = { ...twin, proposed: 0, proposedByRule: {}, skips: [] };
+        try {
+            Object.assign(report, await runOneTwin(twin, deps));
+        }
+        catch (e) {
+            report.failed = String(e?.message ?? e);
+            (0, log_js_1.twinError)(`[twin-rule] "${twin.instanceId}" 규칙을 돌지 못했다 — ${report.failed}`);
+        }
+        out.push(report);
+        if (deps.noteRun) {
+            await deps.noteRun(twin, report).catch(err => (0, log_js_1.twinWarn)(`[twin-rule] "${twin.instanceId}" 규칙 기록을 남기지 못했다 — ${err?.message ?? err}`));
+        }
+    }
+    return out;
+}
+async function runOneTwin(twin, deps) {
+    const rules = await deps.rulesOf(twin);
+    /* 규칙이 없으면 스냅샷도 읽지 않는다 — 아무것도 안 할 일에 값을 만들지 않는다. */
+    if (!rules.length)
+        return {};
+    /*
+     * **이미 올라가 있는 근거를 저장소에서 읽는다.**
+     *
+     * 저장소가 그 길을 내주지 않으면 **판정하지 않는다.** 빈 집합을 만들어 주면 매 주기 같은 조건이 다시
+     * 올라가 대기 줄에 같은 지시가 쌓인다 — 그것을 조용히 하지 않는다.
+     */
+    if (!deps.store.openCauses) {
+        return {
+            skips: [
+                {
+                    ruleId: '(전체)',
+                    reason: '이 저장소는 이미 올라간 근거를 말해 주지 않는다 — 판정하면 같은 조건이 주기마다 다시 올라간다. ' +
+                        'CommandStore.openCauses 가 필요하다'
+                }
+            ]
+        };
+    }
+    /*
+     * ── **시늉된 조건에서 현장 지시를 내지 않는다** (2026-09-01) ────────────
+     *
+     * 시뮬 트윈의 상태는 **가정**이다. 커널이 스스로 물품을 옮겨 만든 병목이고, 현장에서 관측된 것이
+     * 아니다. 그 위에서 생산 지시를 내면 **지어낸 조건이 실제 지시가 된다** — 오늘 자극과 조치를 갈라
+     * 놓은 것과 같은 부류의 잘못이고, 이쪽이 더 나쁘다(자극은 모델 안에서 끝나지만 이것은 현장으로 나간다).
+     *
+     * 실제로 그렇게 걸었다. 오늘 규칙을 확인한 트윈이 전부 `sim` 이었고, 시늉된 병목에서 생산 지시가
+     * 올라왔다. 배선은 옳게 돌았지만 근거는 가정이었다.
+     *
+     * 예측을 근거로 미리 지시를 내는 것 자체는 있을 수 있는 일이다. 다만 그것은 **선언해서** 할 일이고,
+     * 승인하는 사람이 「이것은 예측이다」를 알아야 한다. 그 선언이 아직 없으므로 지금은 막고, 왜 막았는지
+     * 말한다 — 그 문장이 필요해진 사람이 무엇을 요청해야 하는지 알려 준다.
+     */
+    const mode = deps.modeOf(twin);
+    if (mode !== 'live') {
+        return {
+            skips: [
+                {
+                    ruleId: '(전체)',
+                    reason: mode === 'sim'
+                        ? '이 트윈은 시뮬레이션이다 — 시늉된 조건에서 현장 지시를 내지 않는다. ' +
+                            '예측을 근거로 미리 내려면 그것을 선언하는 자리가 필요하고, 아직 없다'
+                        : '이 트윈이 관측을 비추는지 알 수 없다 — 모름을 「관측이다」로 읽지 않는다'
+                }
+            ]
+        };
+    }
+    const attentions = deps.attentionsOf(twin);
+    if (attentions === undefined) {
+        /*
+         * 스냅샷이 없다 — 멈춘 트윈이거나 아직 안 선 트윈이다. **주의가 0건인 것과 다르다.** 0건으로 읽으면
+         * 「조건이 하나도 없다」가 되고, 규칙이 도는 줄로 보인다.
+         */
+        return {
+            skips: [{ ruleId: '(전체)', reason: '이 트윈의 상태를 읽을 수 없다 — 멈춰 있거나 아직 서지 않았다' }]
+        };
+    }
+    const openCauses = await deps.store.openCauses(twin.domainId, twin.instanceId);
+    /* 없으면 넘기지 않는다 — 판정이 「받지 못했다」와 「낸 적이 없다」를 구별해야 한다. */
+    const lastProposedAt = await deps.store.lastProposedAt?.(twin.domainId, twin.instanceId);
+    const verdict = (0, rule_evaluate_js_1.evaluateRules)({
+        rules,
+        attentions,
+        specs: deps.specs,
+        openCauses,
+        ...(lastProposedAt ? { lastProposedAt } : {}),
+        nowMs: deps.nowMs(),
+        ...(deps.maxPerRun ? { maxPerRun: deps.maxPerRun } : {})
+    });
+    const skips = [...verdict.skips];
+    const proposedByRule = {};
+    let proposed = 0;
+    for (const p of verdict.proposals) {
+        try {
+            await (0, command_dispatcher_js_1.propose)(deps.store, twin.domainId, deps.specs, {
+                id: newCommandId(),
+                instanceId: twin.instanceId,
+                type: p.commandType,
+                /* 사람이 아니다. 그래서 낸 사람이 없고, 아무 승인자든 두 번째 사람이 된다. */
+                origin: 'rule',
+                proposedAt: new Date(deps.nowMs()).toISOString(),
+                payload: p.payload,
+                causeRef: p.attentionId,
+                ruleRef: p.ruleId
+            });
+            proposed++;
+            proposedByRule[p.ruleId] = (proposedByRule[p.ruleId] ?? 0) + 1;
+        }
+        catch (e) {
+            /*
+             * 하나가 거절돼도 나머지는 낸다. 그리고 **거절을 삼키지 않는다** — 규칙이 무언가를 내려 했는데
+             * 못 냈다는 사실이 사라지면, 사람은 그 조건에 규칙이 안 걸린 줄로 읽는다.
+             */
+            skips.push({ ruleId: p.ruleId, attentionId: p.attentionId, reason: String(e?.message ?? e) });
+        }
+    }
+    return { proposed, proposedByRule, skips, ...(verdict.withheld ? { withheld: verdict.withheld } : {}) };
+}
+/** 식별자 — 이 파일이 만든다. 저장소가 만들면 커맨드를 적기 전에 근거를 붙일 수 없다. */
+function newCommandId() {
+    return globalThis.crypto.randomUUID();
+}
+//# sourceMappingURL=rule-runner.js.map

package/dist-server/service/actuation/rule-runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-runner.js","sourceRoot":"","sources":["../../../server/service/actuation/rule-runner.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * **규칙을 주기로 돈다** — 판정을 저장소에 잇는 자리.\n *\n * ── 왜 틱이 아닌가 (2026-09-01) ──────────────────────────────────────────\n * 커널 틱 안에 넣으려다 `tickGuarded` 를 읽고 접었다. 그 자리는 **예외가 나면 트윈을 멈추고**, 굶김\n * 감시가 느린 틱 셋에 트윈을 내린다. 규칙 판정은 DB 를 두 번 건드리므로 그 감시에 정확히 걸린다.\n *\n * 그리고 필요하지도 않다. 「병목이 세 시간째」를 1초마다 다시 물을 이유가 없다.\n *\n * ── 규칙은 결재선에 올리지 않는다 ────────────────────────────────────────\n * 이것이 이 파일의 가장 중요한 규율이다.\n *\n * 업무 목록의 결재선은 **올린 사람 기준**으로 풀린다 — `Myself` · `MyDepartment` · `MySupervisor` 가\n * 전부 `context.state.user` 를 본다(§`getSystemUserFromOrgMemberItem`). 배경 루프에는 「나」가 없다.\n * 시스템 사용자를 지어내 넘기면 그 셋이 **시스템 사용자를 가리키게 되고**, 결재선이 뜻을 잃는다.\n *\n * 그래서 규칙은 **내는 것까지** 한다. 결재선에 올리는 것은 사람이 한다(§`raiseTwinCommand`) — 그 사람이\n * 「이것을 승인자들 앞에 놓았다」의 주체가 되고, 그 사람 기준으로 결재선이 풀린다.\n *\n * 올리기 전까지 그 조치는 나가지 못한다. 게이트는 그대로 서 있다.\n */\nimport type { CommandTypeSpec } from '@operato/ops-contract'\n\nimport { twinError, twinWarn } from '../../engine/log.js'\n\nimport { propose, type CommandStore } from './command-dispatcher.js'\nimport { evaluateRules, type ActuationRuleSpec, type AttentionLike, type RuleSkip } from './rule-evaluate.js'\n\n/** 이 프로세스가 든 트윈 하나. */\nexport interface OwnedTwin {\n  domainId: string\n  instanceId: string\n}\n\n/** 한 트윈을 돌고 나서 남는 사실. */\nexport interface TwinRunReport {\n  domainId: string\n  instanceId: string\n  /** 실제로 적힌 커맨드 수. */\n  proposed: number\n  /** 규칙마다 몇 개를 냈나 — 규칙 행에 누계를 적으려면 나누어 세어야 한다. */\n  proposedByRule: Record<string, number>\n  /** 왜 안 올렸나 — 규칙이 조용히 안 도는 것과 조건이 없어서 안 내는 것을 구별한다. */\n  skips: RuleSkip[]\n  /** 상한에 닿아 두고 온 수. */\n  withheld?: number\n  /** 이 트윈을 아예 못 돌았으면 그 이유. */\n  failed?: string\n}\n\n/** 밖에서 받는 것들 — 저장소도 엔진도 시계도 인자다. 그래야 시험이 재기동과 상한을 걸을 수 있다. */\nexport interface RuleRunnerDeps {\n  /** 이 프로세스가 든 트윈들. 남의 프로세스가 든 트윈은 그쪽이 돈다. */\n  ownedTwins(): OwnedTwin[]\n  /** 이 트윈에 걸린 규칙 — 없으면 스냅샷을 읽지 않는다. */\n  rulesOf(twin: OwnedTwin): Promise<ActuationRuleSpec[]>\n  /** 지금 서 있는 주의들. */\n  attentionsOf(twin: OwnedTwin): AttentionLike[] | undefined\n  /**\n   * 이 트윈이 **무엇을 비추고 있나** — 관측(`live`)인가 가정(`sim`)인가.\n   *\n   * 이 값이 없거나 `live` 가 아니면 조치를 내지 않는다(§`runOneTwin`). 모름을 통과로 읽지 않는다.\n   */\n  modeOf(twin: OwnedTwin): 'live' | 'sim' | undefined\n  /** 커맨드가 사는 자리. */\n  store: CommandStore\n  /** 선언된 조치 종류 — 없는 종류를 가리키는 규칙은 판정이 걸러 낸다. */\n  specs: readonly CommandTypeSpec[]\n  nowMs(): number\n  /** 돈 결과를 규칙 행에 남긴다 — 화면이 「이 규칙이 돌고 있나」를 말할 수 있게. */\n  noteRun?(twin: OwnedTwin, report: TwinRunReport): Promise<void>\n  maxPerRun?: number\n}\n\n/**\n * 한 바퀴 돈다 — **한 트윈이 실패해도 나머지는 돈다.**\n *\n * 트윈 하나의 규칙이 잘못됐다고 다른 공장의 규칙이 멈추면, 고치는 동안 전체가 멈춘 셈이 된다.\n */\nexport async function runRulesOnce(deps: RuleRunnerDeps): Promise<TwinRunReport[]> {\n  const out: TwinRunReport[] = []\n\n  for (const twin of deps.ownedTwins()) {\n    const report: TwinRunReport = { ...twin, proposed: 0, proposedByRule: {}, skips: [] }\n    try {\n      Object.assign(report, await runOneTwin(twin, deps))\n    } catch (e: any) {\n      report.failed = String(e?.message ?? e)\n      twinError(`[twin-rule] \"${twin.instanceId}\" 규칙을 돌지 못했다 — ${report.failed}`)\n    }\n    out.push(report)\n\n    if (deps.noteRun) {\n      await deps.noteRun(twin, report).catch(err =>\n        twinWarn(`[twin-rule] \"${twin.instanceId}\" 규칙 기록을 남기지 못했다 — ${err?.message ?? err}`)\n      )\n    }\n  }\n\n  return out\n}\n\nasync function runOneTwin(twin: OwnedTwin, deps: RuleRunnerDeps): Promise<Partial<TwinRunReport>> {\n  const rules = await deps.rulesOf(twin)\n  /* 규칙이 없으면 스냅샷도 읽지 않는다 — 아무것도 안 할 일에 값을 만들지 않는다. */\n  if (!rules.length) return {}\n\n  /*\n   * **이미 올라가 있는 근거를 저장소에서 읽는다.**\n   *\n   * 저장소가 그 길을 내주지 않으면 **판정하지 않는다.** 빈 집합을 만들어 주면 매 주기 같은 조건이 다시\n   * 올라가 대기 줄에 같은 지시가 쌓인다 — 그것을 조용히 하지 않는다.\n   */\n  if (!deps.store.openCauses) {\n    return {\n      skips: [\n        {\n          ruleId: '(전체)',\n          reason:\n            '이 저장소는 이미 올라간 근거를 말해 주지 않는다 — 판정하면 같은 조건이 주기마다 다시 올라간다. ' +\n            'CommandStore.openCauses 가 필요하다'\n        }\n      ]\n    }\n  }\n\n  /*\n   * ── **시늉된 조건에서 현장 지시를 내지 않는다** (2026-09-01) ────────────\n   *\n   * 시뮬 트윈의 상태는 **가정**이다. 커널이 스스로 물품을 옮겨 만든 병목이고, 현장에서 관측된 것이\n   * 아니다. 그 위에서 생산 지시를 내면 **지어낸 조건이 실제 지시가 된다** — 오늘 자극과 조치를 갈라\n   * 놓은 것과 같은 부류의 잘못이고, 이쪽이 더 나쁘다(자극은 모델 안에서 끝나지만 이것은 현장으로 나간다).\n   *\n   * 실제로 그렇게 걸었다. 오늘 규칙을 확인한 트윈이 전부 `sim` 이었고, 시늉된 병목에서 생산 지시가\n   * 올라왔다. 배선은 옳게 돌았지만 근거는 가정이었다.\n   *\n   * 예측을 근거로 미리 지시를 내는 것 자체는 있을 수 있는 일이다. 다만 그것은 **선언해서** 할 일이고,\n   * 승인하는 사람이 「이것은 예측이다」를 알아야 한다. 그 선언이 아직 없으므로 지금은 막고, 왜 막았는지\n   * 말한다 — 그 문장이 필요해진 사람이 무엇을 요청해야 하는지 알려 준다.\n   */\n  const mode = deps.modeOf(twin)\n  if (mode !== 'live') {\n    return {\n      skips: [\n        {\n          ruleId: '(전체)',\n          reason:\n            mode === 'sim'\n              ? '이 트윈은 시뮬레이션이다 — 시늉된 조건에서 현장 지시를 내지 않는다. ' +\n                '예측을 근거로 미리 내려면 그것을 선언하는 자리가 필요하고, 아직 없다'\n              : '이 트윈이 관측을 비추는지 알 수 없다 — 모름을 「관측이다」로 읽지 않는다'\n        }\n      ]\n    }\n  }\n\n  const attentions = deps.attentionsOf(twin)\n  if (attentions === undefined) {\n    /*\n     * 스냅샷이 없다 — 멈춘 트윈이거나 아직 안 선 트윈이다. **주의가 0건인 것과 다르다.** 0건으로 읽으면\n     * 「조건이 하나도 없다」가 되고, 규칙이 도는 줄로 보인다.\n     */\n    return {\n      skips: [{ ruleId: '(전체)', reason: '이 트윈의 상태를 읽을 수 없다 — 멈춰 있거나 아직 서지 않았다' }]\n    }\n  }\n\n  const openCauses = await deps.store.openCauses(twin.domainId, twin.instanceId)\n  /* 없으면 넘기지 않는다 — 판정이 「받지 못했다」와 「낸 적이 없다」를 구별해야 한다. */\n  const lastProposedAt = await deps.store.lastProposedAt?.(twin.domainId, twin.instanceId)\n\n  const verdict = evaluateRules({\n    rules,\n    attentions,\n    specs: deps.specs,\n    openCauses,\n    ...(lastProposedAt ? { lastProposedAt } : {}),\n    nowMs: deps.nowMs(),\n    ...(deps.maxPerRun ? { maxPerRun: deps.maxPerRun } : {})\n  })\n\n  const skips = [...verdict.skips]\n  const proposedByRule: Record<string, number> = {}\n  let proposed = 0\n\n  for (const p of verdict.proposals) {\n    try {\n      await propose(deps.store, twin.domainId, deps.specs, {\n        id: newCommandId(),\n        instanceId: twin.instanceId,\n        type: p.commandType,\n        /* 사람이 아니다. 그래서 낸 사람이 없고, 아무 승인자든 두 번째 사람이 된다. */\n        origin: 'rule',\n        proposedAt: new Date(deps.nowMs()).toISOString(),\n        payload: p.payload,\n        causeRef: p.attentionId,\n        ruleRef: p.ruleId\n      })\n      proposed++\n      proposedByRule[p.ruleId] = (proposedByRule[p.ruleId] ?? 0) + 1\n    } catch (e: any) {\n      /*\n       * 하나가 거절돼도 나머지는 낸다. 그리고 **거절을 삼키지 않는다** — 규칙이 무언가를 내려 했는데\n       * 못 냈다는 사실이 사라지면, 사람은 그 조건에 규칙이 안 걸린 줄로 읽는다.\n       */\n      skips.push({ ruleId: p.ruleId, attentionId: p.attentionId, reason: String(e?.message ?? e) })\n    }\n  }\n\n  return { proposed, proposedByRule, skips, ...(verdict.withheld ? { withheld: verdict.withheld } : {}) }\n}\n\n/** 식별자 — 이 파일이 만든다. 저장소가 만들면 커맨드를 적기 전에 근거를 붙일 수 없다. */\nfunction newCommandId(): string {\n  return globalThis.crypto.randomUUID()\n}\n"]}

package/dist-server/service/actuation/rule-wiring.d.ts

@@ -0,0 +1,24 @@
+import type { ActuationRuleSpec, AttentionLike } from './rule-evaluate.js';
+import type { OwnedTwin, TwinRunReport } from './rule-runner.js';
+/** 이 트윈에 걸린 규칙 — 꺼 둔 것도 함께 준다(판정이 거른다. 「꺼져 있다」는 판정의 규율이다). */
+export declare function rulesOf(twin: OwnedTwin): Promise<ActuationRuleSpec[]>;
+/**
+ * 이 트윈이 관측을 비추나 가정을 돌리나 — 조치를 낼 수 있는지가 여기서 갈린다.
+ *
+ * 판정과 같은 술어를 쓴다(`TwinEngine.modeOf`). 두 벌이면 어긋난다.
+ */
+export declare function modeOf(twin: OwnedTwin): 'live' | 'sim' | undefined;
+/**
+ * 지금 서 있는 주의들 — **못 읽으면 `undefined`.**
+ *
+ * 빈 배열로 답하지 않는다. 멈춘 트윈을 「조건이 하나도 없다」로 읽으면 규칙이 도는 줄로 보인다.
+ * 주의 질의와 같은 원천을 쓴다(§`twin-attention-query.ts`) — 두 곳이 다른 것을 보면 화면에 보이는
+ * 조건과 규칙이 보는 조건이 어긋난다.
+ */
+export declare function attentionsOf(twin: OwnedTwin): AttentionLike[] | undefined;
+/**
+ * 돈 결과를 규칙 행에 남긴다 — **조용히 안 도는 규칙과 조건이 없어서 안 내는 규칙을 구별하려면 필요하다.**
+ *
+ * 이 트윈의 모든 규칙에 `lastRunAt` 을 찍는다. 이유는 그 규칙 것만 적는다.
+ */
+export declare function noteRun(twin: OwnedTwin, report: TwinRunReport): Promise<void>;

package/dist-server/service/actuation/rule-wiring.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rulesOf = rulesOf;
+exports.modeOf = modeOf;
+exports.attentionsOf = attentionsOf;
+exports.noteRun = noteRun;
+/*
+ * 규칙 판정이 **실제 엔진·저장소에 닿는 자리** — 한 벌.
+ *
+ * 리졸버(「지금 돌려 본다」)와 주기 루프가 같은 배선을 써야 한다. 두 벌이면 화면에서 돌려 봤을 때와
+ * 주기가 돌 때가 다르게 동작하고, 사람은 「돌려 봤을 때는 됐는데」를 겪는다.
+ */
+const twin_engine_js_1 = require("../../engine/twin-engine.js");
+const shell_1 = require("@things-factory/shell");
+const actuation_rule_js_1 = require("./actuation-rule.js");
+/** 이 트윈에 걸린 규칙 — 꺼 둔 것도 함께 준다(판정이 거른다. 「꺼져 있다」는 판정의 규율이다). */
+async function rulesOf(twin) {
+    const rows = await (0, shell_1.getRepository)(actuation_rule_js_1.TwinActuationRule).find({
+        where: { domain: { id: twin.domainId }, instanceId: twin.instanceId }
+    });
+    return rows.map(r => ({
+        id: r.id,
+        instanceId: r.instanceId,
+        attentionKind: r.attentionKind,
+        ...(r.minSeverity ? { minSeverity: r.minSeverity } : {}),
+        ...(r.minHeldMs ? { minHeldMs: r.minHeldMs } : {}),
+        ...(r.cooldownMs === null || r.cooldownMs === undefined ? {} : { cooldownMs: r.cooldownMs }),
+        commandType: r.commandType,
+        ...(r.payloadTemplate ? { payloadTemplate: r.payloadTemplate } : {}),
+        enabled: r.enabled !== false
+    }));
+}
+/**
+ * 이 트윈이 관측을 비추나 가정을 돌리나 — 조치를 낼 수 있는지가 여기서 갈린다.
+ *
+ * 판정과 같은 술어를 쓴다(`TwinEngine.modeOf`). 두 벌이면 어긋난다.
+ */
+function modeOf(twin) {
+    return twin_engine_js_1.TwinEngine.modeOf(twin.domainId, twin.instanceId);
+}
+/**
+ * 지금 서 있는 주의들 — **못 읽으면 `undefined`.**
+ *
+ * 빈 배열로 답하지 않는다. 멈춘 트윈을 「조건이 하나도 없다」로 읽으면 규칙이 도는 줄로 보인다.
+ * 주의 질의와 같은 원천을 쓴다(§`twin-attention-query.ts`) — 두 곳이 다른 것을 보면 화면에 보이는
+ * 조건과 규칙이 보는 조건이 어긋난다.
+ */
+function attentionsOf(twin) {
+    if (!twin_engine_js_1.TwinEngine.owns(twin.domainId, twin.instanceId))
+        return undefined;
+    const kernel = twin_engine_js_1.TwinEngine.kernel(twin.domainId, twin.instanceId);
+    const snap = kernel?.getSnapshot?.() ?? twin_engine_js_1.TwinEngine.snapshot(twin.domainId, twin.instanceId);
+    if (!snap)
+        return undefined;
+    return (snap.attentions ?? []);
+}
+/**
+ * 돈 결과를 규칙 행에 남긴다 — **조용히 안 도는 규칙과 조건이 없어서 안 내는 규칙을 구별하려면 필요하다.**
+ *
+ * 이 트윈의 모든 규칙에 `lastRunAt` 을 찍는다. 이유는 그 규칙 것만 적는다.
+ */
+async function noteRun(twin, report) {
+    const repo = (0, shell_1.getRepository)(actuation_rule_js_1.TwinActuationRule);
+    const rows = await repo.find({ where: { domain: { id: twin.domainId }, instanceId: twin.instanceId } });
+    if (!rows.length)
+        return;
+    const at = new Date().toISOString();
+    const reasonOf = (id) => report.skips.filter(s => s.ruleId === id).map(s => s.reason)[0] ?? null;
+    await repo.save(rows.map(row => ({
+        ...row,
+        lastRunAt: at,
+        proposedCount: (row.proposedCount ?? 0) + (report.proposedByRule[row.id] ?? 0),
+        /*
+         * 이유는 그 규칙 것만 적는다. 트윈 전체가 못 돈 경우(§`failed`)는 모든 규칙에 같은 이유가 붙는다
+         * — 그때는 규칙 하나의 문제가 아니기 때문이다.
+         */
+        lastSkipReason: report.failed ?? reasonOf(row.id)
+    })));
+}
+//# sourceMappingURL=rule-wiring.js.map

package/dist-server/service/actuation/rule-wiring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-wiring.js","sourceRoot":"","sources":["../../../server/service/actuation/rule-wiring.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * 규칙 판정이 **실제 엔진·저장소에 닿는 자리** — 한 벌.\n *\n * 리졸버(「지금 돌려 본다」)와 주기 루프가 같은 배선을 써야 한다. 두 벌이면 화면에서 돌려 봤을 때와\n * 주기가 돌 때가 다르게 동작하고, 사람은 「돌려 봤을 때는 됐는데」를 겪는다.\n */\nimport { TwinEngine } from '../../engine/twin-engine.js'\nimport { getRepository } from '@things-factory/shell'\n\nimport { TwinActuationRule } from './actuation-rule.js'\nimport type { ActuationRuleSpec, AttentionLike } from './rule-evaluate.js'\nimport type { OwnedTwin, TwinRunReport } from './rule-runner.js'\n\n/** 이 트윈에 걸린 규칙 — 꺼 둔 것도 함께 준다(판정이 거른다. 「꺼져 있다」는 판정의 규율이다). */\nexport async function rulesOf(twin: OwnedTwin): Promise<ActuationRuleSpec[]> {\n  const rows = await getRepository(TwinActuationRule).find({\n    where: { domain: { id: twin.domainId }, instanceId: twin.instanceId }\n  })\n\n  return rows.map(r => ({\n    id: r.id,\n    instanceId: r.instanceId,\n    attentionKind: r.attentionKind,\n    ...(r.minSeverity ? { minSeverity: r.minSeverity as any } : {}),\n    ...(r.minHeldMs ? { minHeldMs: r.minHeldMs } : {}),\n    ...(r.cooldownMs === null || r.cooldownMs === undefined ? {} : { cooldownMs: r.cooldownMs }),\n    commandType: r.commandType,\n    ...(r.payloadTemplate ? { payloadTemplate: r.payloadTemplate } : {}),\n    enabled: r.enabled !== false\n  }))\n}\n\n/**\n * 이 트윈이 관측을 비추나 가정을 돌리나 — 조치를 낼 수 있는지가 여기서 갈린다.\n *\n * 판정과 같은 술어를 쓴다(`TwinEngine.modeOf`). 두 벌이면 어긋난다.\n */\nexport function modeOf(twin: OwnedTwin): 'live' | 'sim' | undefined {\n  return TwinEngine.modeOf(twin.domainId, twin.instanceId)\n}\n\n/**\n * 지금 서 있는 주의들 — **못 읽으면 `undefined`.**\n *\n * 빈 배열로 답하지 않는다. 멈춘 트윈을 「조건이 하나도 없다」로 읽으면 규칙이 도는 줄로 보인다.\n * 주의 질의와 같은 원천을 쓴다(§`twin-attention-query.ts`) — 두 곳이 다른 것을 보면 화면에 보이는\n * 조건과 규칙이 보는 조건이 어긋난다.\n */\nexport function attentionsOf(twin: OwnedTwin): AttentionLike[] | undefined {\n  if (!TwinEngine.owns(twin.domainId, twin.instanceId)) return undefined\n\n  const kernel = TwinEngine.kernel(twin.domainId, twin.instanceId)\n  const snap = kernel?.getSnapshot?.() ?? TwinEngine.snapshot(twin.domainId, twin.instanceId)\n  if (!snap) return undefined\n\n  return (snap.attentions ?? []) as AttentionLike[]\n}\n\n/**\n * 돈 결과를 규칙 행에 남긴다 — **조용히 안 도는 규칙과 조건이 없어서 안 내는 규칙을 구별하려면 필요하다.**\n *\n * 이 트윈의 모든 규칙에 `lastRunAt` 을 찍는다. 이유는 그 규칙 것만 적는다.\n */\nexport async function noteRun(twin: OwnedTwin, report: TwinRunReport): Promise<void> {\n  const repo = getRepository(TwinActuationRule)\n  const rows = await repo.find({ where: { domain: { id: twin.domainId }, instanceId: twin.instanceId } })\n  if (!rows.length) return\n\n  const at = new Date().toISOString()\n  const reasonOf = (id: string) => report.skips.filter(s => s.ruleId === id).map(s => s.reason)[0] ?? null\n\n  await repo.save(\n    rows.map(row => ({\n      ...row,\n      lastRunAt: at,\n      proposedCount: (row.proposedCount ?? 0) + (report.proposedByRule[row.id] ?? 0),\n      /*\n       * 이유는 그 규칙 것만 적는다. 트윈 전체가 못 돈 경우(§`failed`)는 모든 규칙에 같은 이유가 붙는다\n       * — 그때는 규칙 하나의 문제가 아니기 때문이다.\n       */\n      lastSkipReason: report.failed ?? reasonOf(row.id)\n    })) as any\n  )\n}\n"]}

package/dist-server/service/actuation/settle-effects.d.ts

@@ -0,0 +1,21 @@
+import type { CommandStore } from './command-dispatcher.js';
+import { type OrderObservation } from './effect-match.js';
+/** 봉투에서 오더 보고만 골라낸다 — 다른 어휘는 보지 않는다. */
+export declare function orderObservationsIn(envelopes: readonly any[]): OrderObservation[];
+export interface SettleEffectsResult {
+    /** 효과를 적은 조치 수. */
+    recorded: number;
+    /** 이을 수 없던 보고 수 — 대개 우리가 내지 않은 오더다. */
+    unmatched: number;
+}
+/**
+ * 이 묶음의 오더 보고를 나간 지시와 잇는다 — **아무것도 못 이어도 조용히 지난다.**
+ *
+ * 유입 경로에서 부른다. 그래서 **던지지 않는다** — 효과를 적다 실패해서 관측 유입이 멈추면, 고치는
+ * 동안 트윈이 눈을 감는다. 효과는 다음 보고에 다시 이을 수 있고 관측은 다시 오지 않는다.
+ */
+export declare function settleEffects(args: {
+    domainId: string;
+    envelopes: readonly any[];
+    store: CommandStore;
+}): Promise<SettleEffectsResult>;