@things-factory/headless-twin 10.1.278 → 10.1.279

package/server/service/actuation/twin-now.ts

@@ -1,97 +0,0 @@
-/*
- * **승인하는 사람에게 트윈이 지금 보고 있는 것을 함께 준다.**
- *
- * ── 왜 필요한가 (2026-09-01, 사용자 지적) ────────────────────────────────
- * 사용자가 물었다 — 「보통 AI 는 분명하지 않으면 되묻고, 잘못된 명령이면 확인이나 역제안을 하는데
- * 왜 이 기능에는 그것이 없나.」
- *
- * 확인해 보니 대화하는 AI 는 되묻는다(`twin-ai` §assistant 프롬프트). 그런데 **현장에 지시를 내는
- * 경로는 아무것도 묻지 않는다.** 사람이 「볼트 30개 추가」를 올리면 그대로 결재선에 올라간다. 트윈이
- * 도금 대기가 여섯 배인 것을 알고 있어도 그 말을 할 자리가 없다.
- *
- * 말하는 쪽은 안전한 경로이고, 말 못 하는 쪽이 공장을 움직인다.
- *
- * ── 판정하지 않는다 ──────────────────────────────────────────────────────
- * 트윈이 「이 지시는 틀렸다」고 말하지 않는다. 무엇이 무엇과 어긋나는지 판정하려면 그 규칙을 선언해야
- * 하고, 선언 없이 판정하면 지어낸 규칙이 사람의 지시를 막는다.
- *
- * **트윈은 지금 보이는 것을 내놓고, 승인하는 사람이 판단한다.**
- *
- * ── 이름을 정확히 쓴다 ───────────────────────────────────────────────────
- * 이 값의 이름은 `twinNow` 다. `related` 나 `relevant` 가 아니다 — **이 지시와 관련 있다고 판정한 것이
- * 아니고**, 이 트윈에서 지금 서 있는 것 전부 중 심각한 순서로 몇 개다. 이름이 관련성을 주장하면 승인자가
- * 「트윈이 이 지시 때문에 이것을 골랐다」로 읽는다.
- */
-import { digestAttentions } from '../../engine/attention-digest.js'
-import { TwinEngine } from '../../engine/twin-engine.js'
-
-/** 승인 화면이 읽는 한 줄 — 커널 낱말 그대로. 사람의 말은 표현계층이 만든다. */
-export interface TwinNowAttention {
-  id: string
-  kind: string
-  severity: string
-  anchor?: Record<string, string | undefined>
-  params?: Record<string, string | number>
-  timeStamp?: string
-  /** 커널이 권하는 방향 — 실행 가능한 것과 권고가 섞여 있다(`command` 가 있으면 자극이다). */
-  recommendedActions?: { code: string; command?: string; args?: unknown }[]
-  /** 이 조치가 이것 때문에 올라왔나 — 규칙이 낸 것만 표시된다. */
-  isCause?: boolean
-}
-
-export interface TwinNow {
-  /** 심각한 순서로 몇 개. 전부가 아니다. */
-  attentions: TwinNowAttention[]
-  /** 지금 서 있는 것의 전체 수 — **잘랐으면 몇을 잘랐는지 알 수 있게.** */
-  total: number
-  /** 이 조치를 낸 근거가 아직 서 있나 — 규칙이 낸 것에만 값이 있다. */
-  causeStanding?: boolean
-  /**
-   * 트윈의 상태를 못 읽었으면 그 이유.
-   *
-   * 빈 목록으로 답하지 않는다 — 「지금 아무 문제 없다」와 「트윈이 멈춰 있다」는 다른 사실이고,
-   * 승인하는 사람에게 그 차이가 크다.
-   */
-  unavailable?: string
-}
-
-/** 승인 화면에 몇 개까지 싣나 — 사람이 읽는 수. 스물여섯 줄은 아무도 안 읽는다. */
-export const TWIN_NOW_LIMIT = 5
-
-/**
- * 이 트윈이 지금 무엇을 보고 있나 — 결재선 입력에 실어 보낼 모양으로.
- *
- * `causeRef` 를 주면 그것이 아직 서 있는지도 함께 답한다. 승인하는 사람이 물어야 하는 것 중 가장 중요한
- * 것이 「지금도 그런가」이고, 조건이 사라진 뒤 승인하면 필요 없는 것을 만든다.
- */
-export function twinNow(domainId: string, instanceId: string, causeRef?: string, limit = TWIN_NOW_LIMIT): TwinNow {
-  if (!TwinEngine.owns(domainId, instanceId)) {
-    return { attentions: [], total: 0, unavailable: '이 서버가 이 트윈을 들고 있지 않다 — 멈춰 있거나 다른 서버가 돌고 있다' }
-  }
-
-  const kernel = TwinEngine.kernel(domainId, instanceId)
-  const snap = kernel?.getSnapshot?.() ?? TwinEngine.snapshot(domainId, instanceId)
-  if (!snap) {
-    return { attentions: [], total: 0, unavailable: '이 트윈의 상태를 읽을 수 없다 — 아직 서지 않았거나 멈췄다' }
-  }
-
-  const all = (snap.attentions ?? []) as TwinNowAttention[]
-
-  /* 자리 색은 쓰지 않는다 — 승인 화면은 지도가 아니다. 자른 뒤의 수는 반드시 함께 낸다. */
-  const digest = digestAttentions(all as any, limit)
-
-  const attentions = (digest.attentions as TwinNowAttention[]).map(a => ({
-    ...a,
-    ...(causeRef && a.id === causeRef ? { isCause: true } : {})
-  }))
-
-  return {
-    attentions,
-    total: digest.attentionTotal,
-    /*
-     * 근거가 서 있나 — **자른 목록이 아니라 전량에서 찾는다.** 상위 다섯에 안 들었다고 사라진 것이
-     * 아니다. 잘린 목록에서 찾으면 심각한 것이 여럿일 때 「사라졌다」로 답한다.
-     */
-    ...(causeRef ? { causeStanding: all.some(a => a.id === causeRef) } : {})
-  }
-}

package/server/service/index.ts

@@ -1,100 +0,0 @@
-/* EXPORT ENTITY TYPES */
-export * from './twin-event/twin-event.js'
-export * from './twin-audit/twin-audit-event.js'
-export * from './twin-ingest-window/twin-ingest-window.js'
-export * from './twin-instance/twin-instance.js'
-export * from './twin-space/twin-space.js'
-export * from './twin-space/twin-space-representation.js'
-export * from './twin-space/twin-space-area.js'
-export * from './twin-target/twin-target.js'
-export * from './twin-structure/twin-structure.js'
-export * from './twin-state/twin-state-subscription.js'
-export * from './reference/reference-master.js'
-export * from './reference/reference-registry.js'
-export * from './reference/reference-adapter.js'
-export * from './reference/live-cadence.js'
-export * from './reference/reference-live.js'
-export * from './reference/twin-reference.js'
-export * from './reference/twin-reference-reconciliation.js'
-export * from './reference/reference-reconciliation.js'
-export * from './reference/connection-portability.js'
-export * from './reference/template-registry.js'
-/* 커넥터 점검 하네스 — 실 원본에 붙여 무엇이 채워지고 무엇이 비는지 센다(앱을 띄우지 않는다). */
-export * from './reference/reference-probe.js'
-/* 읽은 뒤의 총평(사실 층) — 화면이 표로 그리고, 더 알고 싶을 때 AI 가 이 사실만 근거로 서술한다. */
-export * from './reference/reference-assessment.js'
-/* 도메인 어휘 카탈로그 조합(커널 SSOT 노출) — 서버측 소비자(board-ai 도구 등)가 같은 형태를 쓰도록. */
-export * from './twin-lifecycle/domain-catalog.js'
-/*
- * 조치 — 앱이 결재선을 채우고(§`setApprovalGateway`) 판정을 옮긴다(§`settleByApproval`). 이 줄이 없으면
- * 자리는 있는데 앱이 닿을 길이 없다.
- */
-export * from './actuation/index.js'
-
-/* IMPORT ENTITIES AND RESOLVERS */
-import { entities as TwinEventEntities } from './twin-event/index.js'
-import { entities as TwinSubjectEntities, resolvers as TwinSubjectResolvers } from './twin-subject/index.js'
-import { entities as TwinAuditEntities, resolvers as TwinAuditResolvers } from './twin-audit/index.js'
-import { entities as TwinInstanceEntities } from './twin-instance/index.js'
-import { entities as TwinStructureEntities } from './twin-structure/index.js'
-import { entities as TwinSpaceEntities, resolvers as TwinSpaceResolvers } from './twin-space/index.js'
-import { entities as TwinTargetEntities, resolvers as TwinTargetResolvers } from './twin-target/index.js'
-import { entities as TwinReferenceEntities, resolvers as TwinReferenceResolvers } from './reference/index.js'
-/* 현장에 내리는 조치 — 승인이 재기동을 넘어 살아야 하므로 표로 든다(§`actuation/twin-command.ts`). */
-import { entities as TwinActuationEntities, resolvers as TwinActuationResolvers } from './actuation/index.js'
-import { resolvers as TwinStateResolvers } from './twin-state/index.js'
-import { resolvers as TwinControlResolvers } from './twin-control/index.js'
-import { entities as TwinModelEntities, resolvers as TwinModelResolvers } from './twin-model/index.js'
-/* 인제스트 창 — 동기화 추이를 재기동 뒤에도 이어 보기 위한 행(리졸버 없음: 메모리 장부가 조회를 답한다). */
-import { entities as TwinIngestWindowEntities, resolvers as TwinIngestWindowResolvers } from './twin-ingest-window/index.js'
-import { resolvers as TwinLifecycleResolvers } from './twin-lifecycle/index.js'
-import { resolvers as TwinJournalResolvers } from './twin-journal/index.js'
-import { resolvers as TwinForecastResolvers } from './twin-forecast/index.js'
-import { resolvers as TwinAttentionResolvers } from './twin-attention/index.js'
-import { resolvers as TwinMetricsResolvers } from './twin-metrics/index.js'
-import { resolvers as TwinReadinessResolvers } from './twin-readiness/index.js'
-/* 지난 기록 채우기 — 저널에만 쓰는 문. 라이브 유입과 판단이 달라 문을 따로 둔다. */
-import { resolvers as TwinBackfillResolvers } from './twin-backfill/index.js'
-
-export const entities = [
-  /* ENTITIES */
-  ...TwinEventEntities,
-  ...TwinSubjectEntities,
-  ...TwinIngestWindowEntities,
-  ...TwinAuditEntities,
-  ...TwinInstanceEntities,
-  ...TwinStructureEntities,
-  ...TwinSpaceEntities,
-  ...TwinTargetEntities,
-  ...TwinReferenceEntities,
-  ...TwinActuationEntities,
-  /* 구조 투영 — model JSON 에서 풀어낸 표준 엔티티(ADR-0032). 원본에서 온 캐시. */
-  ...TwinModelEntities
-]
-
-export const subscribers = []
-
-export const schema = {
-  typeDefs: {},
-  resolverClasses: [
-    /* RESOLVER CLASSES */
-    ...TwinStateResolvers,
-    ...TwinControlResolvers,
-    ...TwinLifecycleResolvers,
-    ...TwinJournalResolvers,
-    ...TwinAuditResolvers,
-    ...TwinForecastResolvers,
-    ...TwinAttentionResolvers,
-    ...TwinMetricsResolvers,
-    ...TwinReadinessResolvers,
-    ...TwinBackfillResolvers,
-    ...TwinIngestWindowResolvers,
-    ...TwinModelResolvers,
-    ...TwinSpaceResolvers,
-    ...TwinTargetResolvers,
-    ...TwinReferenceResolvers,
-    ...TwinActuationResolvers,
-    ...TwinSubjectResolvers
-  ],
-  directives: {}
-}

package/server/service/reference/actuation-routing.ts

@@ -1,192 +0,0 @@
-/*
- * **승인된 조치가 원본으로 나가는 길** — 판단은 `actuation-target.ts`, 여기는 배선.
- *
- * ── 무엇이 끊겨 있었나 (2026-09-02) ────────────────────────────────────────────
- * MES 커넥터는 `actuate` 를 다 만들어 두었다. 서명·접수 판정·초안 상태까지 있었다. 그런데 넘기는
- * 리졸버가 **어댑터를 찾지도 않고** 「구현이 없습니다」라고 답했다. 그 문장을 사실로 읽어서 설계
- * 문서에도, 다른 레인에도 그렇게 알렸다 — 둘 다 틀렸다.
- *
- * 자리는 있고 길이 없는 상태다. 이 저장소에서 가장 자주 나는 결함 부류이고, 조치 경로에서 나면
- * 결과가 하나다 — **승인은 쌓이는데 현장에는 아무것도 가지 않는다.**
- *
- * ── 왜 구동과 따로 두나 ───────────────────────────────────────────────────────
- * 모양이 같아서 한 함수로 묶고 싶어진다. 묶지 않는다.
- *
- *   구동은 시뮬레이터를 움직인다      틀리면 시늉이 어긋난다
- *   조치는 현장에 작업지시를 낸다      틀리면 만들지 않아도 될 것을 만든다
- */
-import { getRepository } from '@things-factory/shell'
-
-import type { ApprovedCommand } from '@operato/ops-contract'
-
-import { TwinInstance } from '../twin-instance/twin-instance.js'
-
-import { TwinReference } from './twin-reference.js'
-import { twinError } from '../../engine/log.js'
-import { actuationOutcomePatch } from './actuation-verification.js'
-import { capabilitiesOf, getAdapter, type ActuationReadiness, type ActuationResult, type SiteDescriptor } from './reference-adapter.js'
-import { APPROVAL_STANDS, actuationTarget, isActuationAllowed, type ActuationTarget } from './actuation-target.js'
-
-/** 어댑터가 답하는 모양 그대로 — 디스패처가 이 값을 커맨드 행에 적는다. */
-/**
- * 조치를 낸 결과 — **어댑터가 답한 것을 좁히지 않고 그대로 나른다.**
- *
- * ── 왜 넓혔나 (2026-09-04, 인티그레이션 레인이 찾음) ────────────────────────
- * 이 타입이 `ok`·`ref`·`error` 셋만 들고 있었다. 그래서 `routeActuation` 이 어댑터의 답을
- * 그대로 되돌리는데 **타입은 `note`·`noteNext`·`retry` 를 버린다고 말했다.**
- *
- * 값은 흘렀다 — JS 객체가 키를 안 버리므로. 어제 `dispatch_note` 에 실제로 앉았다. 그런데
- * **커넥터를 만드는 사람이 그 칸이 있다는 것을 알 방법이 없었다.** 우리가 어제 하루 종일
- * 「자리는 있고 길이 없다」로 부른 것의 타입 버전이다.
- *
- * 좁히지 않는다: 세 칸을 다 실어 `CommandAck` 와 같은 모양으로 둔다. 커널이 어느 칸을 어떻게
- * 쓰는지는 `dispatch` 가 정하고, 이 자리는 나르기만 한다.
- */
-export interface ActuationAck {
-  ok: boolean
-  /** 저쪽 문서·작업 식별자. 없으면 무엇을 되돌릴지 지목할 수 없다. */
-  ref?: string
-  /** 받아들였으나 저쪽이 덧붙인 말 — **실패가 아니다.** 원인 쪽 문장. */
-  note?: string
-  /** 그 말 중 다음에 할 일 한 줄 — 붙여 보내지 않는다. */
-  noteNext?: string
-  error?: string
-  /** 다시 해서 될 일인가 — 실패에만. 말하지 않으면 일꾼이 집지 않는다. */
-  retry?: 'again' | 'after-fix' | 'never'
-}
-
-/**
- * 저장소를 **한 번만** 읽고, 판정과 함께 부를 것까지 돌려준다.
- *
- * 판정한 뒤 보낼 때 다시 읽으면 그 사이에 연결 설정이 바뀔 수 있다 — 판정한 커넥터와 실제로 부르는
- * 커넥터가 달라진다. 그리고 같은 행을 두 번 읽을 이유가 없다.
- */
-async function resolve(domainId: string, instanceId: string) {
-  const inst = await getRepository(TwinInstance).findOne({ where: { domain: { id: domainId }, instanceId } })
-  const ref = inst
-    ? await getRepository(TwinReference).findOne({ where: { domain: { id: domainId }, source: instanceId } })
-    : null
-  const adapter = ref ? getAdapter(ref.adapterType) : undefined
-
-  const target = actuationTarget({
-    instanceId,
-    twinExists: !!inst,
-    siteId: (inst?.origin as any)?.siteId,
-    ...(ref ? { ref: { source: ref.source, adapterType: ref.adapterType } } : {}),
-    adapterRegistered: !!adapter,
-    capabilities: capabilitiesOf(adapter),
-    declaresActuate: !!adapter?.capabilities?.includes('actuate'),
-    hasActuateImpl: typeof adapter?.actuate === 'function'
-  })
-
-  return { target, ref, adapter }
-}
-
-/**
- * 이 트윈의 원본에 승인된 조치를 보낸다.
- *
- * **거절할 때는 무엇이 없어서인지 말한다.** 「보내지 못했습니다」만 답하면 사람이 연결 설정을 열어야
- * 하는지, 커넥터를 고쳐야 하는지, 트윈을 다시 만들어야 하는지 알 수 없다.
- */
-export async function routeActuation(
-  domainId: string,
-  instanceId: string,
-  command: ApprovedCommand
-): Promise<ActuationAck> {
-  const { target, ref, adapter } = await resolve(domainId, instanceId)
-  if (!isActuationAllowed(target)) return { ok: false, error: `${target.detail}. ${APPROVAL_STANDS}` }
-
-  /*
-   * 여기까지 왔으면 판정이 그 둘의 존재를 이미 확인했다(§`actuationTarget`). 그래도 조용히 지나가지
-   * 않는다 — 판정과 배선이 어긋나면 그것이 결함이고, `!` 로 덮으면 그 결함이 「아무 일도 일어나지
-   * 않았다」로 나타난다.
-   */
-  if (!adapter?.actuate) {
-    return { ok: false, error: `커넥터를 찾았는데 조치를 보낼 자리가 없습니다 (${target.adapterType}). ${APPROVAL_STANDS}` }
-  }
-
-  const site: SiteDescriptor = { siteId: target.siteId }
-  const result = await adapter.actuate(ref?.connectionConfig ?? {}, site, command)
-
-  /*
-   * **왕복이 일어났다는 사실을 남긴다** (ADR-0046 ②).
-   *
-   * 설정이 맞는 것과 저쪽이 받는 것은 다르고, 그 차이는 한 번 넘겨 봐야만 안다. 승인 화면이 그것을
-   * 미리 말하려면 지난 왕복의 결과가 어딘가에 남아 있어야 한다 — 없으면 화면은 매번 「해 봐야 안다」만
-   * 말한다.
-   *
-   * 두 경로(`dispatchAfterApproval` · `sweepPendingDispatch`)가 다 이 함수를 지나므로 여기 한 곳이면
-   * 된다. 실패해도 조치 결과는 그대로 돌려준다 — 기록이 본업을 막으면 안 되고, 삼키지도 않는다.
-   */
-  if (ref) await recordActuationOutcome(ref, result).catch(err => twinError('[reference] actuation state not recorded', err))
-
-  return result
-}
-
-/**
- * 조치 결과를 레퍼런스에 적는다 — **코드만, 문장은 아니다.**
- *
- * 거절 사유에 코드가 없으면 `actuationFailure` 를 비워 둔다. 자리를 채우려고 `error` 문장을 옮기면
- * `lastError` 가 이미 겪은 것을 반복한다 — 저장된 문장은 번역도 집계도 안 되고, 커넥터가 그 문장을
- * 고치는 날 옛 행과 새 행이 다른 말을 한다. **모르는 것은 안 적는다.**
- */
-async function recordActuationOutcome(ref: TwinReference, result: ActuationResult): Promise<void> {
-  await getRepository(TwinReference).update({ id: ref.id }, actuationOutcomePatch(result, new Date().toISOString()))
-}
-
-/**
- * 이 트윈이 조치를 받을 수 있나 — **넘기기 전에 화면이 먼저 알 수 있게.**
- *
- * 승인 화면이 「넘기기」를 보이기 전에 이것을 묻는다. 누를 수 없는 것을 보여 주고 눌렀을 때 거절하는
- * 것보다, 왜 못 넘기는지 먼저 말하는 것이 낫다.
- */
-export async function actuationTargetOf(domainId: string, instanceId: string): Promise<ActuationTarget> {
-  return (await resolve(domainId, instanceId)).target
-}
-
-/**
- * **저쪽이 받을 준비가 됐나** — 넘기기 전에 묻는다. 화면이 사람을 헛걸음시키지 않게.
- *
- * ── 왜 `actuationTargetOf` 와 따로인가 ──────────────────────────────────────
- * 그쪽은 **망을 타지 않는다.** 화면이 목록을 그릴 때마다 부를 수 있어야 하므로 그래야 한다.
- * 이 함수는 커넥터가 저쪽에 물을 수 있고, 그래서 부르는 시점이 다르다 — 사람이 「넘기기」를
- * 열었을 때다.
- *
- * ── 답이 문이 아니다 ────────────────────────────────────────────────────────
- * **이 답으로 넘김을 막지 않는다.** 막으면 점검이 틀렸거나 잠깐 못 닿은 사이에 성공할 수 있었던
- * 조치가 못 나간다. 화면이 미리 말하는 데까지가 이 함수의 일이다.
- *
- * 커넥터가 이 얼굴을 안 만들었으면 **「모른다」로 답한다** — 「준비됐다」가 아니다. 없는 확인을
- * 통과로 읽으면 이 함수가 있으나 없으나 같아진다.
- */
-export async function actuationReadinessOf(domainId: string, instanceId: string): Promise<ActuationReadiness> {
-  const { target, ref, adapter } = await resolve(domainId, instanceId)
-
-  /* 보낼 대상 자체가 없으면 저쪽에 물을 것도 없다 — 그 사실을 그대로 옮긴다. */
-  if (!isActuationAllowed(target)) {
-    return { checked: 'local', ready: false, reason: target.detail, code: target.code }
-  }
-
-  if (!adapter?.actuationReadiness) {
-    /* 확인할 길이 없다. 「준비됐다」로 답하지 않는다 — 그러면 화면이 없는 확인을 통과로 읽는다. */
-    return {
-      checked: 'local',
-      reason: `커넥터 "${target.adapterType}" 는 저쪽이 받을 준비가 됐는지 알려 주지 않습니다 — 넘겨 보고 알게 됩니다`,
-      code: 'not-checkable'
-    }
-  }
-
-  try {
-    return await adapter.actuationReadiness(ref?.connectionConfig ?? {}, { siteId: target.siteId })
-  } catch (e: any) {
-    /*
-     * 점검이 터진 것을 「저쪽이 죽었다」로 옮기지 않는다 — 우리 점검의 실패다. 그리고 던지지 않는다:
-     * 이 함수 때문에 승인 화면이 안 열리면, 알려 주려던 것보다 큰 것을 잃는다.
-     */
-    return {
-      checked: 'local',
-      reason: `준비 상태를 확인하다 실패했습니다 — ${String(e?.message ?? e).slice(0, 160)}`,
-      code: 'check-failed'
-    }
-  }
-}

package/server/service/reference/actuation-target.ts

@@ -1,163 +0,0 @@
-/*
- * **조치를 어디로 보낼 수 있나** — 판단만. 저장소도 어댑터 호출도 여기 없다.
- *
- * 배선(§`actuation-routing.ts`)에서 갈라 두는 이유는 규칙 쪽과 같다(§`rule-evaluate.ts`). 이 파일을
- * 부르는 시험이 TypeORM 데코레이터를 지나면 시험이 서지 않고, 그러면 **거절 판정을 아무 시험도 걷지
- * 않는다.** 조치 경로에서 그것은 승인이 쌓이는데 현장에 아무것도 안 가는 상태로 나타난다.
- */
-import type { ReferenceCapability } from './reference-adapter.js'
-
-/** 판단에 필요한 것만 — 엔티티 전체를 받지 않는다. */
-export interface ActuationTargetInput {
-  /** 어느 트윈인가 — **거절 문장이 이것을 말한다.** 「모르는 트윈입니다」만으로는 찾을 수 없다. */
-  instanceId: string
-  /** 트윈이 있나. 없으면 `undefined`. */
-  twinExists: boolean
-  /** 이 트윈이 어느 사이트에서 왔나 — `TwinInstance.origin.siteId`. */
-  siteId?: string
-  /** 연결된 원본. 없으면 `undefined`(시뮬레이션으로만 세운 트윈). */
-  ref?: { source: string; adapterType: string }
-  /** 커넥터가 등록되어 있나. */
-  adapterRegistered: boolean
-  /**
-   * 그 커넥터가 실제로 낼 수 있는 능력 — `capabilitiesOf` 가 판정한 값.
-   *
-   * **낼 수 있나는 이 값만 본다.** 아래 둘은 못 낼 때 무엇을 고쳐야 하는지 말하기 위한 것이고,
-   * 판정을 다시 만들지 않는다.
-   */
-  capabilities: readonly ReferenceCapability[]
-  /** 커넥터가 `capabilities` 에 조치를 적었나. */
-  declaresActuate: boolean
-  /** 커넥터에 `actuate` 함수가 있나. */
-  hasActuateImpl: boolean
-}
-
-/** 보낼 수 있다 — 어디로까지 정해진 상태. */
-export interface ActuationAllowed {
-  ok: true
-  siteId: string
-  adapterType: string
-  source: string
-}
-
-/** 보낼 수 없다 — 왜인지 코드와 문장으로. */
-export interface ActuationRefused {
-  ok: false
-  code: ActuationRefusal
-  detail: string
-}
-
-export type ActuationTarget = ActuationAllowed | ActuationRefused
-
-/**
- * 보낼 수 있나 — **타입 가드로 둔다.**
- *
- * 이 저장소는 기본 설정이 `strict: false` 이고(`packages/tsconfig-base.json`), 그 상태에서는 `ok` 가
- * `true`·`false` 로 갈린 유니온이 `if (!t.ok)` 로 좁혀지지 않는다. 부르는 쪽마다 캐스팅을 넣으면 그
- * 캐스팅이 언젠가 틀린 쪽을 가리킨다. 판정을 여기 한 자리에 둔다.
- */
-export function isActuationAllowed(target: ActuationTarget): target is ActuationAllowed {
-  return target.ok === true
-}
-
-/**
- * 왜 못 보내나 — **코드로 답한다.**
- *
- * 화면이 이 코드로 다음 할 일을 가른다. 문장만 주면 화면은 그것을 그대로 띄우는 것밖에 못 하고,
- * 사람은 연결 설정을 열어야 하는지 커넥터를 고쳐야 하는지 모른다.
- */
-export type ActuationRefusal =
-  | 'unknown-twin'
-  | 'no-source' /* 원본이 없는 트윈 — 보낼 곳이 없다 */
-  | 'no-adapter' /* 커넥터가 등록되지 않았다 */
-  | 'not-declared' /* 구현은 있는데 선언이 없다 — 한 줄 넣으면 된다 */
-  | 'not-implemented' /* 선언은 있는데 구현이 없다 — 만들다 만 커넥터다 */
-  | 'not-supported' /* 선언도 구현도 없다 — 이 커넥터는 관측만 낸다 */
-  | 'no-site' /* 어느 사이트로 낼지 모른다 */
-
-/**
- * 보낼 수 있나 — 보낼 수 있으면 **어디로**까지 답한다.
- *
- * 순서가 뜻을 갖는다. 앞의 것이 없으면 뒤를 물을 수 없다 — 원본을 모르면 능력을 물을 데가 없다.
- */
-export function actuationTarget(input: ActuationTargetInput): ActuationTarget {
-  if (!input.twinExists) {
-    return { ok: false, code: 'unknown-twin', detail: `모르는 트윈입니다 (${input.instanceId})` }
-  }
-
-  if (!input.ref) {
-    /*
-     * 시뮬레이션으로만 세운 트윈이 이 경우다. 규칙 경로가 시뮬 트윈을 이미 막지만
-     * (§`rule-runner.ts`), 사람이 손으로 낸 조치는 그 문을 지나지 않는다. 막는 지점이 두 경로에
-     * 각각 있는 것이고, 같은 판정을 두 벌 만든 것이 아니다.
-     */
-    return {
-      ok: false,
-      code: 'no-source',
-      detail: `트윈 "${input.instanceId}" 에는 연결된 원본이 없습니다 — 보낼 곳이 없습니다`
-    }
-  }
-
-  if (!input.adapterRegistered) {
-    return { ok: false, code: 'no-adapter', detail: `등록되지 않은 커넥터입니다 (${input.ref.adapterType})` }
-  }
-
-  if (!input.capabilities.includes('actuate')) {
-    /*
-     * **왜 못 내는지를 셋으로 가른다** — 고칠 것이 셋 다 다르다.
-     *
-     *   선언 없음 · 구현 있음    한 줄 넣으면 된다
-     *   선언 있음 · 구현 없음    만들다 만 커넥터다. 등록 검사는 이쪽을 말하지 않는다
-     *   선언도 구현도 없음        이 커넥터는 조치를 받지 않는다
-     *
-     * 뭉개면 한 줄로 끝날 일에 커넥터를 다시 만들려 들거나, 반대로 「관측만 냅니다」를 믿고 조치를
-     * 포기한다. 가운데 것을 「관측만 냅니다」로 답하는 것은 **사실이 아니다** — 그 사람은 조치를
-     * 하겠다고 적어 두었다.
-     */
-    const { adapterType, source } = input.ref
-    if (input.hasActuateImpl && !input.declaresActuate) {
-      return {
-        ok: false,
-        code: 'not-declared',
-        detail:
-          `커넥터 "${adapterType}" 가 조치를 보내는 구현은 있는데 능력으로 선언하지 않았습니다 — ` +
-          "connector 의 capabilities 에 'actuate' 를 넣어야 합니다"
-      }
-    }
-    if (input.declaresActuate && !input.hasActuateImpl) {
-      return {
-        ok: false,
-        code: 'not-implemented',
-        detail:
-          `커넥터 "${adapterType}" 가 조치를 보낸다고 선언했는데 그 구현이 없습니다 — ` +
-          'actuate 를 만들거나 선언을 지워야 합니다'
-      }
-    }
-    return {
-      ok: false,
-      code: 'not-supported',
-      detail: `원본 "${source}" (${adapterType}) 는 조치를 받지 않습니다 — 이 커넥터는 관측만 냅니다`
-    }
-  }
-
-  /*
-   * 사이트를 **지어내지 않는다.** 원본 하나가 여러 사이트를 낼 수 있다(`discoverSites`).
-   *
-   * 구동(§`control-routing.ts`)은 사이트를 몰라도 넘긴다 — 시늉을 멈추는 일에는 대상이 하나다.
-   * 조치는 안 된다. 어느 공장에 낼지 모르는 작업지시를 첫 번째 사이트로 보내면 **잘못된 공장이
-   * 실제로 만든다.**
-   */
-  const siteId = String(input.siteId ?? '').trim()
-  if (!siteId) {
-    return {
-      ok: false,
-      code: 'no-site',
-      detail: `트윈 "${input.instanceId}" 이 어느 사이트에서 왔는지 알 수 없습니다 — 조치를 보낼 대상을 정할 수 없습니다`
-    }
-  }
-
-  return { ok: true, siteId, adapterType: input.ref.adapterType, source: input.ref.source }
-}
-
-/** 승인은 남는다는 것을 함께 말한다 — 원인을 고친 뒤 다시 넘길 수 있다. */
-export const APPROVAL_STANDS = '승인은 그대로 남아 있습니다 — 고친 뒤 다시 넘길 수 있습니다'

package/server/service/reference/actuation-verification.ts

@@ -1,85 +0,0 @@
-/*
- * 조치 왕복의 결과를 레퍼런스에 어떻게 적을 것인가 — **순수하게.**
- *
- * `actuation-routing.ts` 에 두면 시험이 그 파일을 들여야 하고, 그 파일은 엔티티를 값으로 들인다
- * (데코레이터가 붙은 클래스). 가벼운 모듈로 떼어 두면 판단만 따로 확인할 수 있다.
- *
- * 여기서 들이는 것은 **타입뿐**이다 — 런타임에 남지 않는다.
- */
-import type { ActuationFailure, ActuationState } from './twin-reference.js'
-import type { ActuationResult } from './reference-adapter.js'
-
-/** 레퍼런스에 적을 칸들. `actuationVerifiedAt` 이 없는 것은 「건드리지 않는다」는 뜻이다. */
-export interface ActuationOutcomePatch {
-  actuationState: ActuationState
-  actuationVerifiedAt?: string
-  actuationFailure: ActuationFailure | null
-}
-
-/**
- * 결과 → 적을 것.
- *
- * ── 세 가지를 지킨다 ───────────────────────────────────────────────────────
- * **받아들여지면 지난 거절을 지운다.** 남겨 두면 화면이 「됐는데 실패 사유가 있다」를 그린다.
- *
- * **거절은 성공 시각을 건드리지 않는다.** 「전에 한 번 닿았다」와 「이번에 안 됐다」는 둘 다 사실이고,
- * 지우면 앞엣것이 사라진다 — 사람이 「한 번이라도 닿은 적 있나」를 물을 자리가 없어진다.
- *
- * **코드가 없으면 사유를 비운다.** 자리를 채우려고 `error` 문장을 옮기지 않는다. `lastError` 가 이미
- * 겪었다 — 저장된 사람 문장은 번역도 집계도 안 되고, 커넥터가 그 문장을 고치는 날 옛 행과 새 행이
- * 서로 다른 말을 한다. 모르는 것은 안 적는다.
- */
-export function actuationOutcomePatch(result: ActuationResult, at: string): ActuationOutcomePatch {
-  if (result.ok) {
-    return { actuationState: 'verified', actuationVerifiedAt: at, actuationFailure: null }
-  }
-
-  return {
-    actuationState: 'failed',
-    actuationFailure: result.errorCode
-      ? { code: result.errorCode, at, ...(result.errorParams ? { params: result.errorParams } : {}) }
-      : null
-  }
-}
-
-/**
- * 조치가 가는 주소를 이루는 칸들 — 이 중 하나라도 바뀌면 지난 왕복은 **다른 주소의 이야기**다.
- *
- * `intakeSiteId` 가 없으면 `siteId` 가 그 자리를 대신한다(부딪힘 판정과 같은 규칙이다 —
- * `connection-portability.ts`). 비밀값을 함께 보는 이유는, 주소가 같아도 저쪽이 우리를 못 알아보면
- * 그 왕복이 다시 성립하지 않기 때문이다.
- */
-const ACTUATION_ADDRESS = ['intakeEndpoint', 'intakeSiteId', 'siteId', 'intakeSecret'] as const
-
-const addressOf = (cfg: Record<string, unknown> | null | undefined) =>
-  ACTUATION_ADDRESS.map(k => String((cfg as any)?.[k] ?? '').trim().replace(/\/$/, '')).join('\u0000')
-
-/**
- * 저장이 조치의 주소를 바꾸나 — **바꿨으면 검증은 저장 시각부터 다시 없다**(ADR-0046 ②).
- *
- * 2026-09-18 실측: 칸 셋은 서 있고 왕복의 결과를 적는 자리도 있는데, 주소를 바꿔도 `verified` 가
- * 그대로 남았다. 화면은 다른 공장을 가리키는 연결을 「확인됨」으로 그린다 — 그 초록이 가장 위험한
- * 거짓이다.
- *
- * `unverified` 는 실패가 아니다. 아직 그 주소로 넘겨 본 적이 없다는 사실이고, 사람이 할 일은 한 번
- * 넘겨 보는 것이다.
- */
-export function actuationResetPatch(
-  before: Record<string, unknown> | null | undefined,
-  after: Record<string, unknown> | null | undefined
-): { actuationState: ActuationState; actuationVerifiedAt: null; actuationFailure: null } | null {
-  if (addressOf(before) === addressOf(after)) return null
-  return { actuationState: 'unverified', actuationVerifiedAt: null, actuationFailure: null }
-}
-
-/**
- * 이 연결이 조치를 **보낼 수 있게 적혀 있나** — 주소가 없으면 어디로도 안 간다.
- *
- * 검증 상태를 화면에 보일지 가르는 값이다. 읽기만 하는 연결(마스터 동기만 하는 커넥터)에 「아직
- * 확인 안 됨」을 그리면, 할 일이 없는 사람에게 할 일이 있는 것처럼 보인다.
- */
-export function actuationAddressed(cfg: Record<string, unknown> | null | undefined): boolean {
-  const endpoint = String((cfg as any)?.intakeEndpoint ?? '').trim()
-  const site = String((cfg as any)?.intakeSiteId ?? (cfg as any)?.siteId ?? '').trim()
-  return !!endpoint && !!site
-}

package/server/service/reference/attention-lane.ts

@@ -1,21 +0,0 @@
-import type { IngestResult } from './reference-hook.js'
-
-export interface AttentionDelivery {
-  domainId: string
-  source: string
-  instanceId: string
-  records: unknown[]
-}
-
-type AttentionHandler = (delivery: AttentionDelivery) => IngestResult | Promise<IngestResult>
-let handler: AttentionHandler | undefined
-
-/** Product modules opt into the ATTENTIONS lane; core owns only transport routing. */
-export function registerAttentionHandler(next: AttentionHandler): void {
-  handler = next
-}
-
-export async function deliverAttention(delivery: AttentionDelivery): Promise<IngestResult> {
-  if (!handler) throw new Error('ATTENTIONS lane has no registered product handler')
-  return await handler(delivery)
-}