@things-factory/headless-twin 10.0.19 → 10.1.0

package/dist-server/service/actuation/command-store.js

@@ -8,6 +8,7 @@ exports.databaseCommandStore = databaseCommandStore;
  * 서지 않는다. 그러면 **게이트의 배선을 아무 시험도 걷지 않게 된다** — 훅에서 이미 겪은 부류다
  * (§`hook-store.ts`).
  */
+const typeorm_1 = require("typeorm");
 const shell_1 = require("@things-factory/shell");
 const read_time_js_1 = require("../../engine/read-time.js");
 const twin_command_js_1 = require("./twin-command.js");
@@ -19,6 +20,10 @@ const twin_command_js_1 = require("./twin-command.js");
  */
 function toCommand(repo, row) {
     return {
+        ...(row.approvalRef ? { approvalRef: row.approvalRef } : {}),
+        ...(row.proposedBy ? { proposedBy: row.proposedBy } : {}),
+        ...(row.causeRef ? { causeRef: row.causeRef } : {}),
+        ...(row.ruleRef ? { ruleRef: row.ruleRef } : {}),
         id: row.id,
         instanceId: row.instanceId,
         type: row.type,
@@ -30,26 +35,184 @@ function toCommand(repo, row) {
         state: row.state,
         ...(row.decidedBy ? { approval: { by: row.decidedBy, at: row.decidedAt ?? '', ...(row.decisionNote ? { note: row.decisionNote } : {}) } } : {}),
         ...(row.dispatchRef ? { dispatchRef: row.dispatchRef } : {}),
+        ...(row.dispatchNote ? { dispatchNote: row.dispatchNote } : {}),
+        /* 셋이 다 있어야 효과다 — 하나라도 비면 적지 않는다(빈 값을 사실로 만들지 않는다). */
+        ...(row.effectStatus && row.effectAt
+            ? { effect: { status: row.effectStatus, at: row.effectAt, seen: row.effectSeen ?? 1 } }
+            : {}),
         ...(row.error ? { error: row.error } : {})
     };
 }
-/** 실제 저장소를 쓰는 구현 — 리졸버가 이것을 넣는다. */
-function databaseCommandStore() {
+/**
+ * 실제 저장소를 쓰는 구현 — 리졸버가 이것을 넣는다.
+ *
+ * **트랜잭션을 받는다.** `getRepository(target)` 를 인자 없이 부르면 요청의 트랜잭션에 붙지 않고
+ * 별도로 커밋된다(`shell/initializers/database.ts:47`). 그러면 「올리고 적기」가 한 덩어리가 아니게 되고,
+ * 뒤가 실패했을 때 앞이 남는다 — 결재선에는 없는데 커맨드는 적혀 직접 결정이 열린 상태다.
+ *
+ * 콜백에서 부를 때도 넘긴다 — 업무 목록의 판정과 우리 커맨드가 같이 커밋되거나 같이 물러나야 한다.
+ */
+function databaseCommandStore(tx) {
     return {
         load: async (domainId, id) => {
-            const repo = await (0, shell_1.getRepository)(twin_command_js_1.TwinCommandRecord);
+            const repo = await (0, shell_1.getRepository)(twin_command_js_1.TwinCommandRecord, tx);
             const row = await repo.findOne({ where: { domain: { id: domainId }, id } }).catch(() => null);
             return row ? toCommand(repo, row) : null;
         },
+        /**
+         * 결정을 기다리는 것들의 **근거** — 규칙이 같은 조건을 두 번 올리지 않게.
+         *
+         * 저장소에서 읽는다. 프로세스 기억에 두면 재기동이 곧 중복이 된다 — 다시 선 트윈이 같은 조건을 처음
+         * 보는 것으로 읽고 대기 줄에 같은 지시를 또 올린다.
+         *
+         * `proposed` 만 본다 — 결정을 기다리는 것은 시간과 무관하게 막는다. 결정이 끝난 것을 언제 다시 낼지는
+         * 이것이 아니라 **기다리는 시간**이 정한다(§`lastProposedAt`).
+         */
+        openCauses: async (domainId, instanceId) => {
+            const repo = await (0, shell_1.getRepository)(twin_command_js_1.TwinCommandRecord, tx);
+            const rows = await repo
+                .find({ where: { domain: { id: domainId }, instanceId, state: 'proposed' }, select: ['causeRef'] })
+                .catch(() => []);
+            return new Set(rows.map(r => r.causeRef).filter((v) => !!v));
+        },
+        /**
+         * 근거마다 **마지막으로 조치를 낸 시각** — 결정이 끝난 것까지 본다.
+         *
+         * `openCauses` 만으로는 부족하다. 승인하는 순간 그 커맨드가 대기에서 빠지고 조건은 그대로 서 있어서
+         * 다음 바퀴가 같은 것을 또 낸다. 실제로 그렇게 됐다 — 승인 한 번에 대기 줄이 다시 찼다.
+         */
+        lastProposedAt: async (domainId, instanceId) => {
+            const repo = await (0, shell_1.getRepository)(twin_command_js_1.TwinCommandRecord, tx);
+            const rows = await repo
+                .find({ where: { domain: { id: domainId }, instanceId }, select: ['causeRef', 'createdAt'] })
+                .catch(() => []);
+            const out = new Map();
+            for (const row of rows) {
+                if (!row.causeRef)
+                    continue;
+                /* 드라이버가 준 값을 직접 날짜로 만들지 않는다 — 컬럼 정의를 보고 푼다. */
+                const at = (0, read_time_js_1.hydratedDate)(repo, 'createdAt', row.createdAt)?.getTime();
+                if (at === undefined || !Number.isFinite(at))
+                    continue;
+                const prev = out.get(row.causeRef);
+                if (prev === undefined || at > prev)
+                    out.set(row.causeRef, at);
+            }
+            return out;
+        },
+        /**
+         * 넘긴 지시의 식별자로 찾는다 — 한 번에 묶어서 묻는다.
+         *
+         * 유입은 초당 수천 건이 지나는 자리다. 관측 하나마다 질의를 붙이면 그 경로가 느려지고, 느려지면
+         * 훅이 밀린다. 그래서 묶음 하나에 질의 하나다.
+         */
+        byDispatchRef: async (domainId, refs) => {
+            const out = new Map();
+            if (!refs.length)
+                return out;
+            const repo = await (0, shell_1.getRepository)(twin_command_js_1.TwinCommandRecord, tx);
+            const rows = await repo
+                .find({ where: { domain: { id: domainId }, dispatchRef: (0, typeorm_1.In)([...new Set(refs)]) } })
+                .catch(() => []);
+            for (const row of rows) {
+                if (row.dispatchRef)
+                    out.set(row.dispatchRef, toCommand(repo, row));
+            }
+            return out;
+        },
+        /**
+         * 효과를 기다리는 조치들 — 넘긴 식별자가 있는 것만.
+         *
+         * 효과가 이미 적힌 것도 낸다. 상태는 여러 번 바뀌고(초안 → 나감 → 진행 중), 마지막 것이 남아야
+         * 화면이 「지금 저쪽에서 무엇인가」에 답할 수 있다.
+         *
+         * 결정이 안 끝난 것과 실패한 것은 빼지 않는다 — 실패로 적혔는데 저쪽은 받았을 수 있고, 그때
+         * 식별자가 있으면 그 사실이 이 길로 드러난다.
+         */
+        awaitingEffect: async (domainId) => {
+            const repo = await (0, shell_1.getRepository)(twin_command_js_1.TwinCommandRecord, tx);
+            const rows = await repo
+                .find({ where: { domain: { id: domainId }, dispatchRef: (0, typeorm_1.Not)((0, typeorm_1.IsNull)()) } })
+                .catch(() => []);
+            return rows.map(row => toCommand(repo, row));
+        },
+        /*
+         * 넘길 차례를 기다리는 것들 — **두 상태만** 본다.
+         *
+         * `approved` 는 승인 직후 발신이 놓친 것(프로세스가 그 사이에 죽었다), `failed` 는 다시 해
+         * 볼 것이다. 그 밖의 상태는 일꾼의 일이 아니다 — `proposed` 는 승인을 기다리고 `acked` 는
+         * 종착이다.
+         *
+         * 물러섬은 여기서 걸러내지 않는다. 걸러내려면 시각 비교를 SQL 방언으로 써야 하고(이 저장소는
+         * 다섯 드라이버를 지난다), 판정은 이미 순수 함수가 한다(§`retryDecisionOf`). 대기 줄이 큰
+         * 현장이 오면 그때 인덱스와 함께 다시 본다.
+         */
+        pendingDispatch: async (domainId) => {
+            const repo = await (0, shell_1.getRepository)(twin_command_js_1.TwinCommandRecord, tx);
+            const rows = await repo
+                .find({ where: { domain: { id: domainId }, state: (0, typeorm_1.In)(['approved', 'failed']) } })
+                .catch(() => []);
+            return rows.map(row => toCommand(repo, row));
+        },
+        /*
+         * 효과만 적는다 — 상태·승인·오류는 건드리지 않는다. 관측이 조치의 수명에 손을 대는 길은 두지
+         * 않는다. 그리고 도메인으로 좁힌다 — 식별자는 시스템마다 겹칠 수 있다.
+         */
+        recordEffects: async (domainId, updates) => {
+            const repo = await (0, shell_1.getRepository)(twin_command_js_1.TwinCommandRecord, tx);
+            for (const u of updates) {
+                await repo.update({ id: u.commandId, domain: { id: domainId } }, { effectStatus: u.status, effectAt: u.at, effectSeen: u.seen });
+            }
+        },
+        /*
+         * **근거는 여기서 안 적는다.** `causeRef`·`ruleRef` 는 낼 때 정해지고 바뀌지 않는다. 이 목록에 넣으면
+         * 상태가 바뀔 때마다 다시 쓰이고, 부르는 쪽이 그 칸을 빼먹은 날 **근거가 지워진다** — 그러면 중복
+         * 판정이 그 커맨드를 못 보고 같은 지시를 또 올린다.
+         */
         save: async (domainId, command) => {
-            await (0, shell_1.getRepository)(twin_command_js_1.TwinCommandRecord).update({ id: command.id, domain: { id: domainId } }, {
+            await (0, shell_1.getRepository)(twin_command_js_1.TwinCommandRecord, tx).update({ id: command.id, domain: { id: domainId } }, {
                 state: command.state,
+                approvalRef: command.approvalRef ?? null,
                 decidedBy: command.approval?.by ?? null,
                 decidedAt: command.approval?.at ?? null,
                 decisionNote: command.approval?.note ?? null,
                 dispatchRef: command.dispatchRef ?? null,
-                error: command.error ?? null
+                dispatchNote: command.dispatchNote ?? null,
+                dispatchNoteNext: command.dispatchNoteNext ?? null,
+                error: command.error ?? null,
+                /* 일꾼이 쓰는 셋 — 없으면 물러섬이 표에 안 남고 재기동마다 즉시 재시도가 된다. */
+                retry: command.retry ?? null,
+                attempts: command.attempts ?? null,
+                nextAttemptAt: command.nextAttemptAt ?? null
+            });
+        },
+        /*
+         * 낼 때는 커맨드가 든 것을 그대로 적는다.
+         *
+         * `proposedAt` 은 옮기지 않는다 — 그 값은 `createdAt` 에서 읽으므로(§`toCommand`), 여기서 또 적으면
+         * 같은 사실이 두 칸에 살고 하나만 고쳐지는 날이 온다. 그리고 되돌려 줄 때는 **적힌 행을 다시 읽는다**
+         * — 낸 값을 그대로 답하면 드라이버가 실제로 무엇을 적었는지 모른 채로 사람에게 보여 준다.
+         */
+        create: async (domainId, command) => {
+            const repo = await (0, shell_1.getRepository)(twin_command_js_1.TwinCommandRecord, tx);
+            const saved = await repo.save({
+                id: command.id,
+                domain: { id: domainId },
+                instanceId: command.instanceId,
+                type: command.type,
+                payload: command.payload ?? null,
+                origin: command.origin,
+                proposedBy: command.proposedBy ?? null,
+                causeRef: command.causeRef ?? null,
+                ruleRef: command.ruleRef ?? null,
+                reversible: command.reversible ?? null,
+                state: command.state,
+                approvalRef: command.approvalRef ?? null
             });
+            const row = await repo.findOne({ where: { domain: { id: domainId }, id: saved.id } });
+            if (!row)
+                throw new Error(`커맨드를 적었는데 다시 읽을 수 없다 (${saved.id})`);
+            return toCommand(repo, row);
         }
     };
 }

package/dist-server/service/actuation/command-store.js.map

@@ -1 +1 @@
-{"version":3,"file":"command-store.js","sourceRoot":"","sources":["../../../server/service/actuation/command-store.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * 커맨드가 저장소에 닿는 두 자리 — 찾는 것과 적는 것.\n *\n * 디스패처가 엔티티를 직접 가져오면 그 파일을 부르는 시험이 TypeORM 데코레이터를 지나게 되고, 시험이\n * 서지 않는다. 그러면 **게이트의 배선을 아무 시험도 걷지 않게 된다** — 훅에서 이미 겪은 부류다\n * (§`hook-store.ts`).\n */\nimport { getRepository } from '@things-factory/shell'\n\nimport type { TwinCommand } from '@operato/ops-contract'\n\nimport { hydratedDate } from '../../engine/read-time.js'\n\nimport { TwinCommandRecord } from './twin-command.js'\nimport type { CommandStore } from './command-dispatcher.js'\n\n/**\n * 행 → 커맨드. 상태 어휘는 계약이 정한 문자열 그대로다.\n *\n * `createdAt` 은 드라이버가 준 값이라 **직접 날짜로 만들지 않는다** — 드라이버마다 모양이 다르고,\n * 문자열로 오는 드라이버에서는 시간대가 없는 값이 된다. `hydratedDate` 가 그 컬럼의 정의를 보고 푼다.\n */\nfunction toCommand(repo: any, row: TwinCommandRecord): TwinCommand {\n  return {\n    id: row.id,\n    instanceId: row.instanceId,\n    type: row.type,\n    ...(row.payload ? { payload: row.payload } : {}),\n    origin: row.origin as TwinCommand['origin'],\n    proposedAt: hydratedDate(repo, 'createdAt', row.createdAt)?.toISOString() ?? '',\n    /* 없는 것을 거짓으로 채우지 않는다 — 비어 있음이 「되돌릴 수 없다」의 뜻이다. */\n    ...(row.reversible === null || row.reversible === undefined ? {} : { reversible: row.reversible }),\n    state: row.state as TwinCommand['state'],\n    ...(row.decidedBy ? { approval: { by: row.decidedBy, at: row.decidedAt ?? '', ...(row.decisionNote ? { note: row.decisionNote } : {}) } } : {}),\n    ...(row.dispatchRef ? { dispatchRef: row.dispatchRef } : {}),\n    ...(row.error ? { error: row.error } : {})\n  }\n}\n\n/** 실제 저장소를 쓰는 구현 — 리졸버가 이것을 넣는다. */\nexport function databaseCommandStore(): CommandStore {\n  return {\n    load: async (domainId: string, id: string) => {\n      const repo = await getRepository(TwinCommandRecord)\n      const row = await repo.findOne({ where: { domain: { id: domainId }, id } }).catch(() => null)\n      return row ? toCommand(repo, row) : null\n    },\n    save: async (domainId: string, command: TwinCommand) => {\n      await getRepository(TwinCommandRecord).update(\n        { id: command.id, domain: { id: domainId } },\n        {\n          state: command.state,\n          decidedBy: command.approval?.by ?? null,\n          decidedAt: command.approval?.at ?? null,\n          decisionNote: command.approval?.note ?? null,\n          dispatchRef: command.dispatchRef ?? null,\n          error: command.error ?? null\n        } as any\n      )\n    }\n  }\n}\n"]}
+{"version":3,"file":"command-store.js","sourceRoot":"","sources":["../../../server/service/actuation/command-store.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * 커맨드가 저장소에 닿는 두 자리 — 찾는 것과 적는 것.\n *\n * 디스패처가 엔티티를 직접 가져오면 그 파일을 부르는 시험이 TypeORM 데코레이터를 지나게 되고, 시험이\n * 서지 않는다. 그러면 **게이트의 배선을 아무 시험도 걷지 않게 된다** — 훅에서 이미 겪은 부류다\n * (§`hook-store.ts`).\n */\nimport { In, IsNull, Not } from 'typeorm'\n\nimport { getRepository } from '@things-factory/shell'\n\nimport type { TwinCommand } from '@operato/ops-contract'\n\nimport { hydratedDate } from '../../engine/read-time.js'\n\nimport { TwinCommandRecord } from './twin-command.js'\nimport type { CommandStore, StoredCommand } from './command-dispatcher.js'\n\n/**\n * 행 → 커맨드. 상태 어휘는 계약이 정한 문자열 그대로다.\n *\n * `createdAt` 은 드라이버가 준 값이라 **직접 날짜로 만들지 않는다** — 드라이버마다 모양이 다르고,\n * 문자열로 오는 드라이버에서는 시간대가 없는 값이 된다. `hydratedDate` 가 그 컬럼의 정의를 보고 푼다.\n */\nfunction toCommand(repo: any, row: TwinCommandRecord): StoredCommand {\n  return {\n    ...(row.approvalRef ? { approvalRef: row.approvalRef } : {}),\n    ...(row.proposedBy ? { proposedBy: row.proposedBy } : {}),\n    ...(row.causeRef ? { causeRef: row.causeRef } : {}),\n    ...(row.ruleRef ? { ruleRef: row.ruleRef } : {}),\n    id: row.id,\n    instanceId: row.instanceId,\n    type: row.type,\n    ...(row.payload ? { payload: row.payload } : {}),\n    origin: row.origin as TwinCommand['origin'],\n    proposedAt: hydratedDate(repo, 'createdAt', row.createdAt)?.toISOString() ?? '',\n    /* 없는 것을 거짓으로 채우지 않는다 — 비어 있음이 「되돌릴 수 없다」의 뜻이다. */\n    ...(row.reversible === null || row.reversible === undefined ? {} : { reversible: row.reversible }),\n    state: row.state as TwinCommand['state'],\n    ...(row.decidedBy ? { approval: { by: row.decidedBy, at: row.decidedAt ?? '', ...(row.decisionNote ? { note: row.decisionNote } : {}) } } : {}),\n    ...(row.dispatchRef ? { dispatchRef: row.dispatchRef } : {}),\n    ...(row.dispatchNote ? { dispatchNote: row.dispatchNote } : {}),\n    /* 셋이 다 있어야 효과다 — 하나라도 비면 적지 않는다(빈 값을 사실로 만들지 않는다). */\n    ...(row.effectStatus && row.effectAt\n      ? { effect: { status: row.effectStatus, at: row.effectAt, seen: row.effectSeen ?? 1 } }\n      : {}),\n    ...(row.error ? { error: row.error } : {})\n  }\n}\n\n/**\n * 실제 저장소를 쓰는 구현 — 리졸버가 이것을 넣는다.\n *\n * **트랜잭션을 받는다.** `getRepository(target)` 를 인자 없이 부르면 요청의 트랜잭션에 붙지 않고\n * 별도로 커밋된다(`shell/initializers/database.ts:47`). 그러면 「올리고 적기」가 한 덩어리가 아니게 되고,\n * 뒤가 실패했을 때 앞이 남는다 — 결재선에는 없는데 커맨드는 적혀 직접 결정이 열린 상태다.\n *\n * 콜백에서 부를 때도 넘긴다 — 업무 목록의 판정과 우리 커맨드가 같이 커밋되거나 같이 물러나야 한다.\n */\nexport function databaseCommandStore(tx?: any): CommandStore {\n  return {\n    load: async (domainId: string, id: string) => {\n      const repo = await getRepository(TwinCommandRecord, tx)\n      const row = await repo.findOne({ where: { domain: { id: domainId }, id } }).catch(() => null)\n      return row ? toCommand(repo, row) : null\n    },\n\n    /**\n     * 결정을 기다리는 것들의 **근거** — 규칙이 같은 조건을 두 번 올리지 않게.\n     *\n     * 저장소에서 읽는다. 프로세스 기억에 두면 재기동이 곧 중복이 된다 — 다시 선 트윈이 같은 조건을 처음\n     * 보는 것으로 읽고 대기 줄에 같은 지시를 또 올린다.\n     *\n     * `proposed` 만 본다 — 결정을 기다리는 것은 시간과 무관하게 막는다. 결정이 끝난 것을 언제 다시 낼지는\n     * 이것이 아니라 **기다리는 시간**이 정한다(§`lastProposedAt`).\n     */\n    openCauses: async (domainId: string, instanceId: string) => {\n      const repo = await getRepository(TwinCommandRecord, tx)\n      const rows = await repo\n        .find({ where: { domain: { id: domainId }, instanceId, state: 'proposed' }, select: ['causeRef'] as any })\n        .catch(() => [] as TwinCommandRecord[])\n\n      return new Set(rows.map(r => r.causeRef).filter((v): v is string => !!v))\n    },\n\n    /**\n     * 근거마다 **마지막으로 조치를 낸 시각** — 결정이 끝난 것까지 본다.\n     *\n     * `openCauses` 만으로는 부족하다. 승인하는 순간 그 커맨드가 대기에서 빠지고 조건은 그대로 서 있어서\n     * 다음 바퀴가 같은 것을 또 낸다. 실제로 그렇게 됐다 — 승인 한 번에 대기 줄이 다시 찼다.\n     */\n    lastProposedAt: async (domainId: string, instanceId: string) => {\n      const repo = await getRepository(TwinCommandRecord, tx)\n      const rows = await repo\n        .find({ where: { domain: { id: domainId }, instanceId }, select: ['causeRef', 'createdAt'] as any })\n        .catch(() => [] as TwinCommandRecord[])\n\n      const out = new Map<string, number>()\n      for (const row of rows) {\n        if (!row.causeRef) continue\n        /* 드라이버가 준 값을 직접 날짜로 만들지 않는다 — 컬럼 정의를 보고 푼다. */\n        const at = hydratedDate(repo, 'createdAt', row.createdAt)?.getTime()\n        if (at === undefined || !Number.isFinite(at)) continue\n        const prev = out.get(row.causeRef)\n        if (prev === undefined || at > prev) out.set(row.causeRef, at)\n      }\n      return out\n    },\n\n    /**\n     * 넘긴 지시의 식별자로 찾는다 — 한 번에 묶어서 묻는다.\n     *\n     * 유입은 초당 수천 건이 지나는 자리다. 관측 하나마다 질의를 붙이면 그 경로가 느려지고, 느려지면\n     * 훅이 밀린다. 그래서 묶음 하나에 질의 하나다.\n     */\n    byDispatchRef: async (domainId: string, refs: readonly string[]) => {\n      const out = new Map<string, StoredCommand>()\n      if (!refs.length) return out\n\n      const repo = await getRepository(TwinCommandRecord, tx)\n      const rows = await repo\n        .find({ where: { domain: { id: domainId }, dispatchRef: In([...new Set(refs)]) } })\n        .catch(() => [] as TwinCommandRecord[])\n\n      for (const row of rows) {\n        if (row.dispatchRef) out.set(row.dispatchRef, toCommand(repo, row))\n      }\n      return out\n    },\n\n    /**\n     * 효과를 기다리는 조치들 — 넘긴 식별자가 있는 것만.\n     *\n     * 효과가 이미 적힌 것도 낸다. 상태는 여러 번 바뀌고(초안 → 나감 → 진행 중), 마지막 것이 남아야\n     * 화면이 「지금 저쪽에서 무엇인가」에 답할 수 있다.\n     *\n     * 결정이 안 끝난 것과 실패한 것은 빼지 않는다 — 실패로 적혔는데 저쪽은 받았을 수 있고, 그때\n     * 식별자가 있으면 그 사실이 이 길로 드러난다.\n     */\n    awaitingEffect: async (domainId: string) => {\n      const repo = await getRepository(TwinCommandRecord, tx)\n      const rows = await repo\n        .find({ where: { domain: { id: domainId }, dispatchRef: Not(IsNull()) } })\n        .catch(() => [] as TwinCommandRecord[])\n      return rows.map(row => toCommand(repo, row))\n    },\n\n    /*\n     * 넘길 차례를 기다리는 것들 — **두 상태만** 본다.\n     *\n     * `approved` 는 승인 직후 발신이 놓친 것(프로세스가 그 사이에 죽었다), `failed` 는 다시 해\n     * 볼 것이다. 그 밖의 상태는 일꾼의 일이 아니다 — `proposed` 는 승인을 기다리고 `acked` 는\n     * 종착이다.\n     *\n     * 물러섬은 여기서 걸러내지 않는다. 걸러내려면 시각 비교를 SQL 방언으로 써야 하고(이 저장소는\n     * 다섯 드라이버를 지난다), 판정은 이미 순수 함수가 한다(§`retryDecisionOf`). 대기 줄이 큰\n     * 현장이 오면 그때 인덱스와 함께 다시 본다.\n     */\n    pendingDispatch: async (domainId: string) => {\n      const repo = await getRepository(TwinCommandRecord, tx)\n      const rows = await repo\n        .find({ where: { domain: { id: domainId }, state: In(['approved', 'failed']) } })\n        .catch(() => [] as TwinCommandRecord[])\n      return rows.map(row => toCommand(repo, row))\n    },\n\n    /*\n     * 효과만 적는다 — 상태·승인·오류는 건드리지 않는다. 관측이 조치의 수명에 손을 대는 길은 두지\n     * 않는다. 그리고 도메인으로 좁힌다 — 식별자는 시스템마다 겹칠 수 있다.\n     */\n    recordEffects: async (domainId: string, updates) => {\n      const repo = await getRepository(TwinCommandRecord, tx)\n      for (const u of updates) {\n        await repo.update(\n          { id: u.commandId, domain: { id: domainId } },\n          { effectStatus: u.status, effectAt: u.at, effectSeen: u.seen } as any\n        )\n      }\n    },\n\n    /*\n     * **근거는 여기서 안 적는다.** `causeRef`·`ruleRef` 는 낼 때 정해지고 바뀌지 않는다. 이 목록에 넣으면\n     * 상태가 바뀔 때마다 다시 쓰이고, 부르는 쪽이 그 칸을 빼먹은 날 **근거가 지워진다** — 그러면 중복\n     * 판정이 그 커맨드를 못 보고 같은 지시를 또 올린다.\n     */\n    save: async (domainId: string, command: StoredCommand) => {\n      await getRepository(TwinCommandRecord, tx).update(\n        { id: command.id, domain: { id: domainId } },\n        {\n          state: command.state,\n          approvalRef: command.approvalRef ?? null,\n          decidedBy: command.approval?.by ?? null,\n          decidedAt: command.approval?.at ?? null,\n          decisionNote: command.approval?.note ?? null,\n          dispatchRef: command.dispatchRef ?? null,\n          dispatchNote: command.dispatchNote ?? null,\n          dispatchNoteNext: command.dispatchNoteNext ?? null,\n          error: command.error ?? null,\n          /* 일꾼이 쓰는 셋 — 없으면 물러섬이 표에 안 남고 재기동마다 즉시 재시도가 된다. */\n          retry: command.retry ?? null,\n          attempts: command.attempts ?? null,\n          nextAttemptAt: command.nextAttemptAt ?? null\n        } as any\n      )\n    },\n\n    /*\n     * 낼 때는 커맨드가 든 것을 그대로 적는다.\n     *\n     * `proposedAt` 은 옮기지 않는다 — 그 값은 `createdAt` 에서 읽으므로(§`toCommand`), 여기서 또 적으면\n     * 같은 사실이 두 칸에 살고 하나만 고쳐지는 날이 온다. 그리고 되돌려 줄 때는 **적힌 행을 다시 읽는다**\n     * — 낸 값을 그대로 답하면 드라이버가 실제로 무엇을 적었는지 모른 채로 사람에게 보여 준다.\n     */\n    create: async (domainId: string, command: StoredCommand) => {\n      const repo = await getRepository(TwinCommandRecord, tx)\n      const saved = await repo.save({\n        id: command.id,\n        domain: { id: domainId },\n        instanceId: command.instanceId,\n        type: command.type,\n        payload: command.payload ?? null,\n        origin: command.origin,\n        proposedBy: command.proposedBy ?? null,\n        causeRef: command.causeRef ?? null,\n        ruleRef: command.ruleRef ?? null,\n        reversible: command.reversible ?? null,\n        state: command.state,\n        approvalRef: command.approvalRef ?? null\n      } as any)\n\n      const row = await repo.findOne({ where: { domain: { id: domainId }, id: saved.id } })\n      if (!row) throw new Error(`커맨드를 적었는데 다시 읽을 수 없다 (${saved.id})`)\n      return toCommand(repo, row)\n    }\n  }\n}\n"]}

package/dist-server/service/actuation/dispatch-after-approval.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 승인이 확정된 조치를 **커밋 뒤에** 현장으로 넘긴다.
+ *
+ * 부르는 쪽은 기다리지 않는다(`void`). 결재의 성공은 넘김의 성공에 달려 있지 않다 — 어댑터가
+ * 죽어 있어도 승인은 남아 있어야 하고, 그것이 승인과 넘김을 가른 이유다.
+ *
+ * **던지지 않는다.** 이 함수는 요청 밖에서 돌기 때문에, 던지면 처리되지 않은 거절이 되어
+ * 프로세스를 내린다. 넘기다 생긴 실패는 `dispatch` 가 `failed` 로 앉히고, 그 위의 예외(상태가
+ * 맞지 않음·커맨드가 사라짐)만 여기서 받아 적는다.
+ */
+export declare function dispatchAfterApproval(domainId: string, commandId: string): void;

package/dist-server/service/actuation/dispatch-after-approval.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchAfterApproval = dispatchAfterApproval;
+/*
+ * **승인 다음에 넘긴다** — 승인 도장과 실제 발신 사이의 한 걸음.
+ *
+ * ── 무엇이 없었나 (2026-09-04) ──────────────────────────────────────────────
+ * 사람이 결재함에서 승인하면 커맨드가 `approved` 로 앉고 **거기서 멈췄다.** 그것을 집어 현장에
+ * 보내는 것이 아무것도 없었다 — 규칙 타이머는 조치를 *내는* 일만 하고, 화면에는 넘기기 단추가
+ * 없다. 폐루프를 라이브로 확인한 것도 사람이 뮤테이션을 손으로 불러서였다.
+ *
+ * 그래서 승인은 아무 데도 닿지 않았고, 현장은 오지 않는 지시를 기다렸다. 오류는 나지 않는다.
+ *
+ * ── 왜 승인 트랜잭션 안에서 보내지 않나 ─────────────────────────────────────
+ * 승인은 업무 목록의 트랜잭션 안에서 일어난다. 그 안에서 현장에 요청을 쏘면 두 가지가 깨진다.
+ *
+ *   ① 롤백이 되돌리지 못한다. 공장에는 작업지시가 생겼는데 우리 장부는 승인을 취소한 상태가 된다.
+ *      **네트워크로 나간 것은 트랜잭션이 못 되돌린다.**
+ *   ② 트랜잭션이 원격 응답을 기다리는 동안 열려 있다. 저쪽이 느리면 결재 화면이 함께 멈춘다.
+ *
+ * 그래서 **커밋 다음으로 미룬다.** 미루면 「미룬 사이에 롤백됐으면?」이 남는데, 그것은
+ * `dispatch` 가 스스로 막는다 — 새 연결로 커맨드를 **다시 읽고** 상태를 확인한다. 롤백됐으면
+ * 승인 기록이 없어 그 자리에서 던진다(§`asApproved`). 우리가 따로 검사할 것이 없다.
+ *
+ * ── 정직한 한계 ─────────────────────────────────────────────────────────────
+ * 커밋과 발신 사이에 프로세스가 죽으면 그 커맨드는 `approved` 로 남는다. **잃지는 않지만 스스로
+ * 나가지도 않는다.** 그것을 사람이 볼 자리(「넘기지 못한 조치」 목록)와 다시 넘기는 길이 아직
+ * 없다 — 이 파일이 그 빈 자리를 메우지 않는다는 것을 여기 적어 둔다.
+ *
+ * 그리고 이 미룸은 **한 프로세스 안의 약속**이다. 여러 대로 늘리면 승인을 받은 프로세스가
+ * 보내는 것이 되고, 그 프로세스가 죽으면 위와 같다. 그때는 표를 보고 집어 가는 일꾼이 필요하다.
+ */
+const log_js_1 = require("../../engine/log.js");
+const command_store_js_1 = require("./command-store.js");
+const command_dispatcher_js_1 = require("./command-dispatcher.js");
+const actuation_routing_js_1 = require("../reference/actuation-routing.js");
+/**
+ * 승인이 확정된 조치를 **커밋 뒤에** 현장으로 넘긴다.
+ *
+ * 부르는 쪽은 기다리지 않는다(`void`). 결재의 성공은 넘김의 성공에 달려 있지 않다 — 어댑터가
+ * 죽어 있어도 승인은 남아 있어야 하고, 그것이 승인과 넘김을 가른 이유다.
+ *
+ * **던지지 않는다.** 이 함수는 요청 밖에서 돌기 때문에, 던지면 처리되지 않은 거절이 되어
+ * 프로세스를 내린다. 넘기다 생긴 실패는 `dispatch` 가 `failed` 로 앉히고, 그 위의 예외(상태가
+ * 맞지 않음·커맨드가 사라짐)만 여기서 받아 적는다.
+ */
+function dispatchAfterApproval(domainId, commandId) {
+    /*
+     * `setImmediate` 로 미룬다 — 지금 열린 트랜잭션이 커밋될 기회를 준다.
+     *
+     * 이것이 커밋을 **보장하지는 않는다.** 보장은 `dispatch` 의 다시 읽기가 한다(머리말). 여기서
+     * 미루는 것은 「대개 커밋된 뒤에 읽게 하려는」 것이고, 아니면 다시 읽기가 거절한다.
+     */
+    setImmediate(() => {
+        void (async () => {
+            try {
+                const settled = await (0, command_dispatcher_js_1.dispatch)((0, command_store_js_1.databaseCommandStore)(), domainId, commandId, command => (0, actuation_routing_js_1.routeActuation)(domainId, command.instanceId, command));
+                if (settled.state === 'failed') {
+                    /* 실패는 결함이 아니다 — 저쪽이 안 받았거나 설정이 비었다는 사실이고, 행에 남는다. */
+                    (0, log_js_1.twinWarn)(`[twin-actuation] 조치 ${commandId} 를 넘기지 못했다: ${settled.error ?? '(사유 없음)'}`);
+                }
+            }
+            catch (e) {
+                /*
+                 * 여기 오는 것은 「넘길 수 없는 상태」다. 가장 흔한 원인은 **승인 트랜잭션이 롤백된 것**이고,
+                 * 그때는 넘기지 않는 것이 맞다. 조용히 지나가지 않고 적는다 — 다른 원인이면 그것이 결함이다.
+                 */
+                (0, log_js_1.twinWarn)(`[twin-actuation] 조치 ${commandId} 를 넘기지 않았다: ${String(e?.message ?? e)}`);
+            }
+        })();
+    });
+}
+//# sourceMappingURL=dispatch-after-approval.js.map

package/dist-server/service/actuation/dispatch-after-approval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch-after-approval.js","sourceRoot":"","sources":["../../../server/service/actuation/dispatch-after-approval.ts"],"names":[],"mappings":";;AA4CA,sDA0BC;AAtED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,gDAA8C;AAC9C,yDAAyD;AACzD,mEAAkD;AAClD,4EAAkE;AAElE;;;;;;;;;GASG;AACH,SAAgB,qBAAqB,CAAC,QAAgB,EAAE,SAAiB;IACvE;;;;;OAKG;IACH,YAAY,CAAC,GAAG,EAAE;QAChB,KAAK,CAAC,KAAK,IAAI,EAAE;YACf,IAAI,CAAC;gBACH,MAAM,OAAO,GAAG,MAAM,IAAA,gCAAQ,EAAC,IAAA,uCAAoB,GAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,CACpF,IAAA,qCAAc,EAAC,QAAQ,EAAE,OAAO,CAAC,UAAU,EAAE,OAAO,CAAC,CACtD,CAAA;gBACD,IAAI,OAAO,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;oBAC/B,qDAAqD;oBACrD,IAAA,iBAAQ,EAAC,uBAAuB,SAAS,eAAe,OAAO,CAAC,KAAK,IAAI,SAAS,EAAE,CAAC,CAAA;gBACvF,CAAC;YACH,CAAC;YAAC,OAAO,CAAM,EAAE,CAAC;gBAChB;;;mBAGG;gBACH,IAAA,iBAAQ,EAAC,uBAAuB,SAAS,eAAe,MAAM,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC,CAAC,EAAE,CAAC,CAAA;YACpF,CAAC;QACH,CAAC,CAAC,EAAE,CAAA;IACN,CAAC,CAAC,CAAA;AACJ,CAAC","sourcesContent":["/*\n * **승인 다음에 넘긴다** — 승인 도장과 실제 발신 사이의 한 걸음.\n *\n * ── 무엇이 없었나 (2026-09-04) ──────────────────────────────────────────────\n * 사람이 결재함에서 승인하면 커맨드가 `approved` 로 앉고 **거기서 멈췄다.** 그것을 집어 현장에\n * 보내는 것이 아무것도 없었다 — 규칙 타이머는 조치를 *내는* 일만 하고, 화면에는 넘기기 단추가\n * 없다. 폐루프를 라이브로 확인한 것도 사람이 뮤테이션을 손으로 불러서였다.\n *\n * 그래서 승인은 아무 데도 닿지 않았고, 현장은 오지 않는 지시를 기다렸다. 오류는 나지 않는다.\n *\n * ── 왜 승인 트랜잭션 안에서 보내지 않나 ─────────────────────────────────────\n * 승인은 업무 목록의 트랜잭션 안에서 일어난다. 그 안에서 현장에 요청을 쏘면 두 가지가 깨진다.\n *\n *   ① 롤백이 되돌리지 못한다. 공장에는 작업지시가 생겼는데 우리 장부는 승인을 취소한 상태가 된다.\n *      **네트워크로 나간 것은 트랜잭션이 못 되돌린다.**\n *   ② 트랜잭션이 원격 응답을 기다리는 동안 열려 있다. 저쪽이 느리면 결재 화면이 함께 멈춘다.\n *\n * 그래서 **커밋 다음으로 미룬다.** 미루면 「미룬 사이에 롤백됐으면?」이 남는데, 그것은\n * `dispatch` 가 스스로 막는다 — 새 연결로 커맨드를 **다시 읽고** 상태를 확인한다. 롤백됐으면\n * 승인 기록이 없어 그 자리에서 던진다(§`asApproved`). 우리가 따로 검사할 것이 없다.\n *\n * ── 정직한 한계 ─────────────────────────────────────────────────────────────\n * 커밋과 발신 사이에 프로세스가 죽으면 그 커맨드는 `approved` 로 남는다. **잃지는 않지만 스스로\n * 나가지도 않는다.** 그것을 사람이 볼 자리(「넘기지 못한 조치」 목록)와 다시 넘기는 길이 아직\n * 없다 — 이 파일이 그 빈 자리를 메우지 않는다는 것을 여기 적어 둔다.\n *\n * 그리고 이 미룸은 **한 프로세스 안의 약속**이다. 여러 대로 늘리면 승인을 받은 프로세스가\n * 보내는 것이 되고, 그 프로세스가 죽으면 위와 같다. 그때는 표를 보고 집어 가는 일꾼이 필요하다.\n */\nimport { twinWarn } from '../../engine/log.js'\nimport { databaseCommandStore } from './command-store.js'\nimport { dispatch } from './command-dispatcher.js'\nimport { routeActuation } from '../reference/actuation-routing.js'\n\n/**\n * 승인이 확정된 조치를 **커밋 뒤에** 현장으로 넘긴다.\n *\n * 부르는 쪽은 기다리지 않는다(`void`). 결재의 성공은 넘김의 성공에 달려 있지 않다 — 어댑터가\n * 죽어 있어도 승인은 남아 있어야 하고, 그것이 승인과 넘김을 가른 이유다.\n *\n * **던지지 않는다.** 이 함수는 요청 밖에서 돌기 때문에, 던지면 처리되지 않은 거절이 되어\n * 프로세스를 내린다. 넘기다 생긴 실패는 `dispatch` 가 `failed` 로 앉히고, 그 위의 예외(상태가\n * 맞지 않음·커맨드가 사라짐)만 여기서 받아 적는다.\n */\nexport function dispatchAfterApproval(domainId: string, commandId: string): void {\n  /*\n   * `setImmediate` 로 미룬다 — 지금 열린 트랜잭션이 커밋될 기회를 준다.\n   *\n   * 이것이 커밋을 **보장하지는 않는다.** 보장은 `dispatch` 의 다시 읽기가 한다(머리말). 여기서\n   * 미루는 것은 「대개 커밋된 뒤에 읽게 하려는」 것이고, 아니면 다시 읽기가 거절한다.\n   */\n  setImmediate(() => {\n    void (async () => {\n      try {\n        const settled = await dispatch(databaseCommandStore(), domainId, commandId, command =>\n          routeActuation(domainId, command.instanceId, command)\n        )\n        if (settled.state === 'failed') {\n          /* 실패는 결함이 아니다 — 저쪽이 안 받았거나 설정이 비었다는 사실이고, 행에 남는다. */\n          twinWarn(`[twin-actuation] 조치 ${commandId} 를 넘기지 못했다: ${settled.error ?? '(사유 없음)'}`)\n        }\n      } catch (e: any) {\n        /*\n         * 여기 오는 것은 「넘길 수 없는 상태」다. 가장 흔한 원인은 **승인 트랜잭션이 롤백된 것**이고,\n         * 그때는 넘기지 않는 것이 맞다. 조용히 지나가지 않고 적는다 — 다른 원인이면 그것이 결함이다.\n         */\n        twinWarn(`[twin-actuation] 조치 ${commandId} 를 넘기지 않았다: ${String(e?.message ?? e)}`)\n      }\n    })()\n  })\n}\n"]}

package/dist-server/service/actuation/effect-match.d.ts

@@ -0,0 +1,53 @@
+import type { ISOTime } from '@operato/ops-contract';
+/** 관측 하나 — 오더 상태 보고에서 필요한 것만. */
+export interface OrderObservation {
+    orderId: string;
+    status: string;
+    /** 이 보고를 관측한 시각. 없으면 이을 수 없다 — 언제인지 모르는 효과는 적지 않는다. */
+    at?: ISOTime;
+}
+/** 이을 대상 — 저장소가 `dispatchRef` 로 찾아 준 조치. */
+export interface DispatchedCommand {
+    id: string;
+    dispatchRef: string;
+    /** 이미 적힌 효과가 있나 — 몇 번 보고됐는지를 이어서 센다. */
+    effect?: {
+        status: string;
+        at: ISOTime;
+        seen: number;
+    };
+}
+/** 적을 것 하나. */
+export interface EffectUpdate {
+    commandId: string;
+    status: string;
+    at: ISOTime;
+    seen: number;
+}
+export interface EffectMatch {
+    updates: EffectUpdate[];
+    /** 이을 수 없던 관측과 그 이유 — 조용히 버리지 않는다. */
+    skips: {
+        orderId: string;
+        reason: string;
+    }[];
+}
+/**
+ * 한 번에 여러 관측을 잇는다.
+ *
+ * **같은 오더가 한 묶음에 여러 번 올 수 있다.** 그때는 마지막 것이 남고 `seen` 이 그만큼 는다 —
+ * 중간 상태를 덮어쓰는 것이 맞다(화면이 묻는 것은 「지금 저쪽에서 무엇인가」다). 다만 몇 번 바뀌었는지는
+ * 남긴다. 한 번도 안 바뀐 것과 다섯 번 바뀐 것은 다른 일이다.
+ */
+export declare function matchEffects(args: {
+    observations: readonly OrderObservation[];
+    /** `dispatchRef` → 그 지시를 낸 조치. 저장소가 채운다. */
+    byRef: ReadonlyMap<string, DispatchedCommand>;
+}): EffectMatch;
+/**
+ * 이 묶음에서 **찾아봐야 할 오더 식별자**만 골라낸다 — 저장소에 물을 것을 줄인다.
+ *
+ * 관측 한 묶음이 수백 건일 수 있고 그중 우리가 낸 것은 몇 건이다. 전부를 하나씩 물으면 유입 경로에
+ * 질의가 그만큼 붙는다 — 유입은 초당 수천 건이 지나는 자리다.
+ */
+export declare function refsToLookUp(observations: readonly OrderObservation[]): string[];

package/dist-server/service/actuation/effect-match.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchEffects = matchEffects;
+exports.refsToLookUp = refsToLookUp;
+/**
+ * 한 번에 여러 관측을 잇는다.
+ *
+ * **같은 오더가 한 묶음에 여러 번 올 수 있다.** 그때는 마지막 것이 남고 `seen` 이 그만큼 는다 —
+ * 중간 상태를 덮어쓰는 것이 맞다(화면이 묻는 것은 「지금 저쪽에서 무엇인가」다). 다만 몇 번 바뀌었는지는
+ * 남긴다. 한 번도 안 바뀐 것과 다섯 번 바뀐 것은 다른 일이다.
+ */
+function matchEffects(args) {
+    const { observations, byRef } = args;
+    const updates = new Map();
+    const skips = [];
+    for (const ob of observations) {
+        const orderId = String(ob?.orderId ?? '').trim();
+        if (!orderId) {
+            skips.push({ orderId: '', reason: '오더 식별자가 없는 보고 — 이을 수 없다' });
+            continue;
+        }
+        const command = byRef.get(orderId);
+        if (!command) {
+            /*
+             * 대개 이것이다 — 우리가 내지 않은 오더의 상태 보고. 저쪽 시스템은 자기 오더를 다 보고하고,
+             * 그중 우리가 낸 것은 일부다. **이유로 남기되 흔한 것임을 적어 둔다** — 이 줄이 쌓이는 것을
+             * 결함으로 읽으면 안 된다.
+             */
+            skips.push({ orderId, reason: '우리가 낸 지시가 아니다' });
+            continue;
+        }
+        const status = String(ob?.status ?? '').trim();
+        if (!status) {
+            /* 빈 상태를 적으면 「보고는 왔는데 아무 말도 안 했다」가 「효과 없음」과 같아 보인다. */
+            skips.push({ orderId, reason: '상태를 말하지 않은 보고 — 빈 값을 효과로 적지 않는다' });
+            continue;
+        }
+        const at = String(ob?.at ?? '').trim();
+        if (!at) {
+            /* 언제인지 모르는 효과는 적지 않는다 — 「지금」으로 채우면 관측 시각이 아니라 처리 시각이 된다. */
+            skips.push({ orderId, reason: '시각이 없는 보고 — 지금으로 채우지 않는다' });
+            continue;
+        }
+        /* 같은 묶음 안에서 앞서 센 것이 있으면 그것을 잇는다 — 없으면 적힌 효과에서 잇는다. */
+        const prior = updates.get(command.id)?.seen ?? command.effect?.seen ?? 0;
+        updates.set(command.id, { commandId: command.id, status, at, seen: prior + 1 });
+    }
+    return { updates: [...updates.values()], skips };
+}
+/**
+ * 이 묶음에서 **찾아봐야 할 오더 식별자**만 골라낸다 — 저장소에 물을 것을 줄인다.
+ *
+ * 관측 한 묶음이 수백 건일 수 있고 그중 우리가 낸 것은 몇 건이다. 전부를 하나씩 물으면 유입 경로에
+ * 질의가 그만큼 붙는다 — 유입은 초당 수천 건이 지나는 자리다.
+ */
+function refsToLookUp(observations) {
+    const out = new Set();
+    for (const ob of observations) {
+        const orderId = String(ob?.orderId ?? '').trim();
+        if (orderId)
+            out.add(orderId);
+    }
+    return [...out];
+}
+//# sourceMappingURL=effect-match.js.map

package/dist-server/service/actuation/effect-match.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-match.js","sourceRoot":"","sources":["../../../server/service/actuation/effect-match.ts"],"names":[],"mappings":";;AA4DA,oCAgDC;AAQD,oCAOC;AAtED;;;;;;GAMG;AACH,SAAgB,YAAY,CAAC,IAI5B;IACC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,GAAG,IAAI,CAAA;IAEpC,MAAM,OAAO,GAAG,IAAI,GAAG,EAAwB,CAAA;IAC/C,MAAM,KAAK,GAA0C,EAAE,CAAA;IAEvD,KAAK,MAAM,EAAE,IAAI,YAAY,EAAE,CAAC;QAC9B,MAAM,OAAO,GAAG,MAAM,CAAC,EAAE,EAAE,OAAO,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAA;QAChD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,KAAK,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,yBAAyB,EAAE,CAAC,CAAA;YAC9D,SAAQ;QACV,CAAC;QAED,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;QAClC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb;;;;eAIG;YACH,KAAK,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC,CAAA;YAChD,SAAQ;QACV,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAA;QAC9C,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,sDAAsD;YACtD,KAAK,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,iCAAiC,EAAE,CAAC,CAAA;YAClE,SAAQ;QACV,CAAC;QAED,MAAM,EAAE,GAAG,MAAM,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAA;QACtC,IAAI,CAAC,EAAE,EAAE,CAAC;YACR,4DAA4D;YAC5D,KAAK,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,0BAA0B,EAAE,CAAC,CAAA;YAC3D,SAAQ;QACV,CAAC;QAED,sDAAsD;QACtD,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,IAAI,IAAI,OAAO,CAAC,MAAM,EAAE,IAAI,IAAI,CAAC,CAAA;QACxE,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,GAAG,CAAC,EAAE,CAAC,CAAA;IACjF,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,CAAA;AAClD,CAAC;AAED;;;;;GAKG;AACH,SAAgB,YAAY,CAAC,YAAyC;IACpE,MAAM,GAAG,GAAG,IAAI,GAAG,EAAU,CAAA;IAC7B,KAAK,MAAM,EAAE,IAAI,YAAY,EAAE,CAAC;QAC9B,MAAM,OAAO,GAAG,MAAM,CAAC,EAAE,EAAE,OAAO,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAA;QAChD,IAAI,OAAO;YAAE,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;IAC/B,CAAC;IACD,OAAO,CAAC,GAAG,GAAG,CAAC,CAAA;AACjB,CAAC","sourcesContent":["/*\n * **나간 지시와 돌아온 관측을 잇는다** — 폐루프의 마지막 칸. 판단만, 저장소는 여기 없다.\n *\n * ── 왜 이 칸이 비어 있었나 (2026-09-02) ───────────────────────────────────────\n * `dispatchRef` 를 **쓰는 곳만 있고 읽는 곳이 없었다.** 어댑터가 답한 작업지시 이름을 적어 두는데,\n * 그 이름으로 무엇도 찾지 않았다. 그래서 조치를 넘긴 뒤 저쪽에서 그것이 어떻게 됐는지 트윈은 몰랐다.\n *\n * 자리는 있고 길이 없는 상태다. 조치 경로에서 이 부류가 나면 결과가 하나다 — **넘긴 것이 현장에서\n * 무엇이 되었는지 아무도 모르는데, 화면은 「넘겼다」까지만 보여 주고 끝난 것처럼 읽힌다.**\n *\n * ── 커널은 무엇이 효과인지 정하지 않는다 ─────────────────────────────────────\n * 오더 상태 어휘는 도메인 소유다(§`OrderStatusDelta.status` — `status: string`, 코어는 강제하지\n * 않는다). 어느 값이 「현장에 나갔다」인지는 현장마다 다르고, 커널이 그 방언을 알면 보편 계약이\n * 깨진다 — 흐름 판정이 공정 이름을 설비 종류로 환산하지 않는 것과 같은 이유다.\n *\n * 그래서 여기서 판단하는 것은 **이어지나** 하나다.\n *\n *   이 관측의 오더 식별자가 우리가 낸 지시의 식별자와 같은가\n *\n * 같으면 그 상태를 **해석하지 않고 그대로** 적는다. 무엇을 뜻하는지는 그 어휘를 아는 쪽이 읽는다.\n */\nimport type { ISOTime } from '@operato/ops-contract'\n\n/** 관측 하나 — 오더 상태 보고에서 필요한 것만. */\nexport interface OrderObservation {\n  orderId: string\n  status: string\n  /** 이 보고를 관측한 시각. 없으면 이을 수 없다 — 언제인지 모르는 효과는 적지 않는다. */\n  at?: ISOTime\n}\n\n/** 이을 대상 — 저장소가 `dispatchRef` 로 찾아 준 조치. */\nexport interface DispatchedCommand {\n  id: string\n  dispatchRef: string\n  /** 이미 적힌 효과가 있나 — 몇 번 보고됐는지를 이어서 센다. */\n  effect?: { status: string; at: ISOTime; seen: number }\n}\n\n/** 적을 것 하나. */\nexport interface EffectUpdate {\n  commandId: string\n  status: string\n  at: ISOTime\n  seen: number\n}\n\nexport interface EffectMatch {\n  updates: EffectUpdate[]\n  /** 이을 수 없던 관측과 그 이유 — 조용히 버리지 않는다. */\n  skips: { orderId: string; reason: string }[]\n}\n\n/**\n * 한 번에 여러 관측을 잇는다.\n *\n * **같은 오더가 한 묶음에 여러 번 올 수 있다.** 그때는 마지막 것이 남고 `seen` 이 그만큼 는다 —\n * 중간 상태를 덮어쓰는 것이 맞다(화면이 묻는 것은 「지금 저쪽에서 무엇인가」다). 다만 몇 번 바뀌었는지는\n * 남긴다. 한 번도 안 바뀐 것과 다섯 번 바뀐 것은 다른 일이다.\n */\nexport function matchEffects(args: {\n  observations: readonly OrderObservation[]\n  /** `dispatchRef` → 그 지시를 낸 조치. 저장소가 채운다. */\n  byRef: ReadonlyMap<string, DispatchedCommand>\n}): EffectMatch {\n  const { observations, byRef } = args\n\n  const updates = new Map<string, EffectUpdate>()\n  const skips: { orderId: string; reason: string }[] = []\n\n  for (const ob of observations) {\n    const orderId = String(ob?.orderId ?? '').trim()\n    if (!orderId) {\n      skips.push({ orderId: '', reason: '오더 식별자가 없는 보고 — 이을 수 없다' })\n      continue\n    }\n\n    const command = byRef.get(orderId)\n    if (!command) {\n      /*\n       * 대개 이것이다 — 우리가 내지 않은 오더의 상태 보고. 저쪽 시스템은 자기 오더를 다 보고하고,\n       * 그중 우리가 낸 것은 일부다. **이유로 남기되 흔한 것임을 적어 둔다** — 이 줄이 쌓이는 것을\n       * 결함으로 읽으면 안 된다.\n       */\n      skips.push({ orderId, reason: '우리가 낸 지시가 아니다' })\n      continue\n    }\n\n    const status = String(ob?.status ?? '').trim()\n    if (!status) {\n      /* 빈 상태를 적으면 「보고는 왔는데 아무 말도 안 했다」가 「효과 없음」과 같아 보인다. */\n      skips.push({ orderId, reason: '상태를 말하지 않은 보고 — 빈 값을 효과로 적지 않는다' })\n      continue\n    }\n\n    const at = String(ob?.at ?? '').trim()\n    if (!at) {\n      /* 언제인지 모르는 효과는 적지 않는다 — 「지금」으로 채우면 관측 시각이 아니라 처리 시각이 된다. */\n      skips.push({ orderId, reason: '시각이 없는 보고 — 지금으로 채우지 않는다' })\n      continue\n    }\n\n    /* 같은 묶음 안에서 앞서 센 것이 있으면 그것을 잇는다 — 없으면 적힌 효과에서 잇는다. */\n    const prior = updates.get(command.id)?.seen ?? command.effect?.seen ?? 0\n    updates.set(command.id, { commandId: command.id, status, at, seen: prior + 1 })\n  }\n\n  return { updates: [...updates.values()], skips }\n}\n\n/**\n * 이 묶음에서 **찾아봐야 할 오더 식별자**만 골라낸다 — 저장소에 물을 것을 줄인다.\n *\n * 관측 한 묶음이 수백 건일 수 있고 그중 우리가 낸 것은 몇 건이다. 전부를 하나씩 물으면 유입 경로에\n * 질의가 그만큼 붙는다 — 유입은 초당 수천 건이 지나는 자리다.\n */\nexport function refsToLookUp(observations: readonly OrderObservation[]): string[] {\n  const out = new Set<string>()\n  for (const ob of observations) {\n    const orderId = String(ob?.orderId ?? '').trim()\n    if (orderId) out.add(orderId)\n  }\n  return [...out]\n}\n"]}

package/dist-server/service/actuation/index.d.ts

@@ -1,6 +1,25 @@
+import { TwinActuationRule } from './actuation-rule.js';
+import { TwinActuationRuleResolver } from './actuation-rule-resolver.js';
 import { TwinCommandRecord } from './twin-command.js';
-export declare const entities: (typeof TwinCommandRecord)[];
-export declare const resolvers: any[];
+import { TwinCommandResolver } from './twin-command-resolver.js';
+export declare const entities: (typeof TwinCommandRecord | typeof TwinActuationRule)[];
+export declare const resolvers: (typeof TwinActuationRuleResolver | typeof TwinCommandResolver)[];
 export * from './twin-command.js';
+export * from './actuation-rule.js';
+export * from './approval-gateway.js';
+export * from './dispatch-after-approval.js';
+export * from './actuation-outcome.js';
+export * from './retry-plan.js';
+export * from './sweep-dispatch.js';
+export * from './actuation-advisor.js';
 export * from './command-dispatcher.js';
 export * from './command-store.js';
+export * from './twin-now.js';
+export * from './effect-match.js';
+export * from './settle-effects.js';
+export * from './catch-up-effects.js';
+export * from './rule-evaluate.js';
+export * from './rule-runner.js';
+export * from './rule-loop.js';
+export * from './twin-command-resolver.js';
+export * from './actuation-rule-resolver.js';

package/dist-server/service/actuation/index.js

@@ -2,10 +2,29 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolvers = exports.entities = void 0;
 const tslib_1 = require("tslib");
+const actuation_rule_js_1 = require("./actuation-rule.js");
+const actuation_rule_resolver_js_1 = require("./actuation-rule-resolver.js");
 const twin_command_js_1 = require("./twin-command.js");
-exports.entities = [twin_command_js_1.TwinCommandRecord];
-exports.resolvers = [];
+const twin_command_resolver_js_1 = require("./twin-command-resolver.js");
+exports.entities = [twin_command_js_1.TwinCommandRecord, actuation_rule_js_1.TwinActuationRule];
+exports.resolvers = [twin_command_resolver_js_1.TwinCommandResolver, actuation_rule_resolver_js_1.TwinActuationRuleResolver];
 tslib_1.__exportStar(require("./twin-command.js"), exports);
+tslib_1.__exportStar(require("./actuation-rule.js"), exports);
+tslib_1.__exportStar(require("./approval-gateway.js"), exports);
+tslib_1.__exportStar(require("./dispatch-after-approval.js"), exports);
+tslib_1.__exportStar(require("./actuation-outcome.js"), exports);
+tslib_1.__exportStar(require("./retry-plan.js"), exports);
+tslib_1.__exportStar(require("./sweep-dispatch.js"), exports);
+tslib_1.__exportStar(require("./actuation-advisor.js"), exports);
 tslib_1.__exportStar(require("./command-dispatcher.js"), exports);
 tslib_1.__exportStar(require("./command-store.js"), exports);
+tslib_1.__exportStar(require("./twin-now.js"), exports);
+tslib_1.__exportStar(require("./effect-match.js"), exports);
+tslib_1.__exportStar(require("./settle-effects.js"), exports);
+tslib_1.__exportStar(require("./catch-up-effects.js"), exports);
+tslib_1.__exportStar(require("./rule-evaluate.js"), exports);
+tslib_1.__exportStar(require("./rule-runner.js"), exports);
+tslib_1.__exportStar(require("./rule-loop.js"), exports);
+tslib_1.__exportStar(require("./twin-command-resolver.js"), exports);
+tslib_1.__exportStar(require("./actuation-rule-resolver.js"), exports);
 //# sourceMappingURL=index.js.map

package/dist-server/service/actuation/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../server/service/actuation/index.ts"],"names":[],"mappings":";;;;AAAA,uDAAqD;AAExC,QAAA,QAAQ,GAAG,CAAC,mCAAiB,CAAC,CAAA;AAC9B,QAAA,SAAS,GAAG,EAAE,CAAA;AAE3B,4DAAiC;AACjC,kEAAuC;AACvC,6DAAkC","sourcesContent":["import { TwinCommandRecord } from './twin-command.js'\n\nexport const entities = [TwinCommandRecord]\nexport const resolvers = []\n\nexport * from './twin-command.js'\nexport * from './command-dispatcher.js'\nexport * from './command-store.js'\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../server/service/actuation/index.ts"],"names":[],"mappings":";;;;AAAA,2DAAuD;AACvD,6EAAwE;AACxE,uDAAqD;AACrD,yEAAgE;AAEnD,QAAA,QAAQ,GAAG,CAAC,mCAAiB,EAAE,qCAAiB,CAAC,CAAA;AACjD,QAAA,SAAS,GAAG,CAAC,8CAAmB,EAAE,sDAAyB,CAAC,CAAA;AAEzE,4DAAiC;AACjC,8DAAmC;AACnC,gEAAqC;AACrC,uEAA4C;AAC5C,iEAAsC;AACtC,0DAA+B;AAC/B,8DAAmC;AACnC,iEAAsC;AACtC,kEAAuC;AACvC,6DAAkC;AAClC,wDAA6B;AAC7B,4DAAiC;AACjC,8DAAmC;AACnC,gEAAqC;AACrC,6DAAkC;AAClC,2DAAgC;AAChC,yDAA8B;AAC9B,qEAA0C;AAC1C,uEAA4C","sourcesContent":["import { TwinActuationRule } from './actuation-rule.js'\nimport { TwinActuationRuleResolver } from './actuation-rule-resolver.js'\nimport { TwinCommandRecord } from './twin-command.js'\nimport { TwinCommandResolver } from './twin-command-resolver.js'\n\nexport const entities = [TwinCommandRecord, TwinActuationRule]\nexport const resolvers = [TwinCommandResolver, TwinActuationRuleResolver]\n\nexport * from './twin-command.js'\nexport * from './actuation-rule.js'\nexport * from './approval-gateway.js'\nexport * from './dispatch-after-approval.js'\nexport * from './actuation-outcome.js'\nexport * from './retry-plan.js'\nexport * from './sweep-dispatch.js'\nexport * from './actuation-advisor.js'\nexport * from './command-dispatcher.js'\nexport * from './command-store.js'\nexport * from './twin-now.js'\nexport * from './effect-match.js'\nexport * from './settle-effects.js'\nexport * from './catch-up-effects.js'\nexport * from './rule-evaluate.js'\nexport * from './rule-runner.js'\nexport * from './rule-loop.js'\nexport * from './twin-command-resolver.js'\nexport * from './actuation-rule-resolver.js'\n"]}