Continuum

Overview

Continuum คือ foundation ของ nectarserve — ระบบที่อ่านข้อความแล้วลงมือกับโลกจริง · ทุกอย่าง derive จาก AX1–AX5

Axioms · Theorems · Corollaries   พิสูจน์แล้ว
Design                            เลือกไว้
รอยต่อ                            จุดที่ต่อกับโลกจริง

Theorems

T1–T5 · T7–T9 เป็น theorem สากล — อยู่ที่ Systems

T6 · เปลี่ยน Resolver ไม่เปลี่ยนสิ่งที่ทำไปแล้ว

จาก T1 + Parcel.provenance (immutable)

เปลี่ยน resolver = เปลี่ยน วิธีทำครั้งต่อไป — ไม่ได้เปลี่ยนสิ่งที่ทำไปแล้ว · provenance เป็น record ที่แก้ไม่ได้

รองรับ — C5

T10 · เวลาที่ผ่านไปโดยไม่ทำงานมีต้นทุน

จาก AX2 + AX3

inaction ไม่ใช่ neutral — โลกขยับระหว่างที่ระบบนิ่ง · idle_ok จึงเป็น constraint ไม่ใช่แค่ alert

T11 · Thread context มี clarity และ staleness เป็นของตัวเอง

จาก AX4 + AX1

จัด thread ผิด → error กระจายแบบ multiplicative ทุก gate หลังจากนั้นทำงานบน context ที่ผิด · staleness ของ thread คือกรณีเฉพาะของ T17 (ความจำทุกชนิด drift)

T12 · Identity confidence กำหนดขอบเขต mandate

จาก AX1 + AX5

confidence สูง → full mandate · confidence ต่ำ → conservative mandate · ต่ำกว่า min → block + verify

T13 · Provenance มีขอบเขตเหมือน Parcel อื่น

จาก T1 + AX2

provenance ยิ่งโต = carrying cost ยิ่งเพิ่ม — ไม่ใช่ free storage · trim ตามกฎ + extract learning data ก่อนเสมอ

รองรับ — C9

T14 · Intent ตัดสินไม่ได้โดยไม่รู้ thread

จาก AX4

“ffffff” อาจเป็น hex color, ความเกรี้ยวกราด, หรือ noise → ต้อง resolve thread ก่อน check intent เสมอ

รองรับ — C8

T15 · Mandate คือ context ที่ครบของ task

จาก AX5 + T9

“ทำ mandate ให้ชัด” = “ทำ context ให้ครบ” = “เพิ่ม clarity” · mandate ที่ไม่ชัด = clarity ต่ำ = execute ไม่ได้

T16 · Gate คือ CommitOperation — pipeline 10 ด่าน

จาก AX1–AX5 + T9 + T14

ทุกข้อความผ่านด่านที่กำหนดไว้แน่นอนก่อน LLM ถูกเรียก — ลำดับนี้ไม่ใช่อิสระ แต่ละด่าน derive จาก axiom:

1.  noise filter      drop ถ้าไม่มีภาษาที่รู้จัก           (AX5)
2.  thread resolve    รู้ context ก่อน                     (AX4)
3.  identity          confidence → ขอบเขต mandate          (T12)
4.  clarity check     block ถ้า < threshold                (AX5 · T9)
5.  idle detect       escalate ถ้านิ่งเกิน                  (T10)
6.  select mandate    block ถ้าไม่มี mandate ตรง            (T15)
7.  constraint check                                       (AX2)
8.  blast radius      external + irreversible → human       (T8)
9.  ack decide                                             (AX3 · T7)
10. dispatch                                               (AX2)

clarity check (4) มาก่อน constraint check (7) เสมอ — ตาม T9

T17 · ความจำคือค่าประมาณที่ drift — จับได้แค่ความแน่ใจ ไม่ใช่ความจริง

จาก AX1 + AX3

ความจำคือ representation lossy (AX1) ของโลกที่ขยับเอง (AX3) · ตอนบันทึก ความจำตรงกับโลก · เวลาผ่าน → ห่างกันโดยไม่มีสัญญาณเตือน · ∴ ทุกความจำมี ความแน่ใจ (ว่ายังตรงจริงไหม) ติดมาเสมอ แยกจากค่าไม่ได้ · วัดตรงๆ ไม่ได้ — ต้อง re-observe และการ re-observe เปลี่ยนสิ่งที่วัด (Observer Effect) → ระบบถือได้แค่ ค่าประมาณของความแน่ใจ ไม่ใช่ความจริง

รองรับ — T11 (กรณีเฉพาะ: thread staleness)

Corollaries

C6 · C7 · C10 · C11 เป็น corollary สากล — อยู่ที่ Systems

C1 · ออกแบบ interaction space ไม่ใช่ entity space

จาก AX1 + T4

entity ที่ model ล่วงหน้า = ทำก่อนจำเป็น · ออกแบบ interaction ที่เกิดจริงแทน แล้ว entity จะ emerge เอง

C2 · ผูกกับ Unix เพราะ interaction surface

จาก C1 + T4

Unix process ที่ไม่รู้จัก manifest → context ผ่านทั้งหมด · ที่รู้จัก manifest → progressive enhancement · สองกรณีไม่ขัดกัน = backward compatible โดยธรรมชาติ

C3 · เข้าใจขอบเขตของงานก่อน เพื่อ optimize ถึงมันได้อย่างตั้งใจ

จาก T3 + T5

ออกแบบก่อนรู้ขอบเขต = เสี่ยง violation โดยไม่รู้ตัว · ออกแบบหลังรู้ขอบเขต = เลือกได้ว่าจะ optimize ที่จุดไหน

C4 · Local ก่อน Cloud เสมอ

จาก AX2 + T1

code ทำได้ → ทำเลย · local LLM พอ → ใช้ local · local ไม่พอ → escalate · ต้อง best จริง → API

C5 · Parcel เดินทาง, ResolverContext ไม่เดินทาง

จาก AX1 + T6

ส่ง Parcel ข้าม boundary ได้เสมอ · environment ปลายทาง execute ด้วย pool ของตัวเอง

C8 · Thread เป็น unit of meaning ไม่ใช่ message

จาก AX4 + T14

ระบบที่รับ message ทีละข้อความโดยไม่รู้ thread = กำลัง execute โดยมี clarity ต่ำโดยไม่รู้ตัว

C9 · Provenance ไม่ใช่ free storage

จาก T13 + AX2

trim ตาม blast_radius + extract learning data ก่อนเสมอ — ของ external + irreversible เก็บนาน · ของ internal + reversible trim เร็ว

C12 · Bootstrap — loop เริ่มได้เมื่อมีครบสาม

จาก AX2 + AX5 + C11

channel (ทางเข้าข้อมูล) + mandate (ขอบเขตที่ทำได้ อย่างน้อยหนึ่ง) + resolver (กลไกประมวลผล) · ต่ำกว่านี้ ingest ได้แต่ act ไม่ได้ · เท่านี้ loop เริ่มได้ — ไม่สมบูรณ์ แต่พอ (C11)

C13 · Complexity อยู่ข้างใน ไม่ใช่ข้างหน้า

จาก C10 + T4

ผู้ใช้เห็น “ลูกค้าทักมา ระบบตอบได้” · ระบบทำ noise → thread → intent → clarity → mandate → … · complexity ที่ซ่อนข้างใน = คุณค่าที่ระบบส่งมอบ · วัด UX ด้วย: “ผู้ใช้ต้องรู้ internal mechanism ไหมถึงใช้ได้?” ถ้าใช่ = ยังซ่อนไม่พอ

C14 · Channel คือหูของ Resolver

จาก C12 + AX4

channel ที่ไม่มี resolver = ท่อ ไม่ใช่ระบบ · channel ได้ความหมายเมื่อ resolver รับมัน · ∴ mental model ที่ถูกคือ “เชื่อม resolver เข้ากับ channel” ไม่ใช่ “เพิ่ม channel แล้ว resolver จะไปอยู่” — resolver เป็นศูนย์กลาง, channel คือ input path ที่ resolver ฟัง

Design

ไม่ใช่ความจริงที่ปฏิเสธไม่ได้ แต่คือ choice ที่ axioms ทำให้สมเหตุสมผลที่สุด

Parcel — primitive เดียวของระบบ

จาก AX1 + T6

Parcel = {
  form:       bytes            ← สิ่งที่ทำไปแล้ว
  manifest:   Context          ← สิ่งที่รออยู่
  provenance: CommitRecord[]   ← ประวัติ immutable
}

Parcel = data เดินทางผ่านระบบได้เสมอ · ResolverContext = runtime รู้จัก environment ไม่เดินทาง · CommitOperation = boundary ที่นิ่งระหว่างสองอย่าง

Memory — สามระดับ

จาก AX1 + AX2 + AX4

memory ≠ log · memory คือ distilled context สำหรับ resolver · เช็คง่าย: “ลบ node นี้แล้ว resolver ตัดสินใจแย่ลงไหม?” ไม่ = เป็นแค่ log

L1 — Raw observation   ลบได้ (log ชั่วคราว · TTL + evict)
L2 — Distilled         ลืมยากแต่ decay ได้ (weight = e^(−λ·days))
L3 — Core pattern      update ได้ถ้าผิด

L2 คือ inference ไม่ใช่ fact — “somchai ชอบกาแฟร้อน” = น่าจะจริง (confidence=0.78) ไม่ใช่ จริงแน่นอน · และ inference ที่พูดออกไปเปลี่ยน state ของลูกค้า → ใช้เงียบๆ เพื่อตัดสินใจเท่านั้น ไม่ประกาศว่ารู้ (Observer Effect · AX3)

รอยต่อ

รอยต่อคือจุดที่ระบบไปต่อกับโลกจริง · ส่วนใหญ่เป็นรอยต่อตื้น — ของจริงเติมค่าครั้งเดียวก็กลายเป็น setting แล้วปิด

แต่มีรอยต่อหนึ่งที่ปิดไม่ได้เลย — ความจำของระบบกับโลกที่มันอ้างถึง · โลกขยับเองได้ (AX3) และการกลับไปเช็กก็เปลี่ยนสิ่งที่วัด (Observer Effect) ช่องว่างนี้จึงไม่มีวันปิดสนิท (T17) · รอยต่อที่เหลืออยู่จริงจึงเป็นเรื่องเดียว — ความแน่ใจของความจำ

ที่ยังเปิดอยู่คือ จะทำให้ความแน่ใจนั้นโผล่ให้เห็นและจัดการยังไง

เพราะความแน่ใจของแต่ละความจำไม่เท่ากัน ระบบจึงแสดงมันไม่เท่ากัน — เงียบกับของที่ยังสด ยกขึ้นเฉพาะของที่ความแน่ใจตก ให้เจ้าของยืนยันเมื่อว่าง · ไม่มีอะไรน่าสงสัยก็ไม่ต้องถาม

ผลคือระบบที่บอกได้ว่าจำอะไรไว้ และไม่แน่ใจกับอันไหน

สองเหตุการณ์ที่ยังเปิดอยู่

ทั้งคู่คือ เหตุการณ์ที่ขยับความแน่ใจ ไม่ใช่ชนิดของความจำ:

#1 · เรียนจากคำติ — เหตุการณ์ที่ แก้ ความแน่ใจ · ลูกค้าบ่น → รู้ว่าความจำหรือการตัดสินใจไหนผิด → ปรับ · แก่นคือ credit assignment: โทษให้ถูกตัวจากสัญญาณที่กำกวม เบาบาง และมาช้า

#2 · เครื่องมือเปลี่ยน — เหตุการณ์ที่ ลด ความแน่ใจ · ความจำที่เรียนจากพฤติกรรมเก่าของเครื่องมืออาจผิดเมื่อเครื่องมือเปลี่ยน → ต้องรู้ว่าความจำชิ้นไหนผูกกับเครื่องมือไหน แล้วดึงความแน่ใจลงให้ทบทวน

ทั้งสองไม่ใช่ฟีเจอร์แยก — ลงเอยที่กลไกเดียวกัน

หลักของชั้นนี้

เริ่มจากสิ่งที่วัดได้ (สังเกต/log ก่อน) → ปล่อยให้ structure emerge → ค่อย tune · กฎที่เขียนก่อนมี data มักผิด จึงให้ของจริงเป็นคนตั้งค่าตรงรอยต่อ ไม่เดาล่วงหน้า (สอดคล้อง C13)