TriadicFrameworks
अवलोकन

ऑपरेटर व्याकरण — घटना उपस्ट्रेट मॉडल

दस्तावेज़: operator_grammar.md पथ: /docs/Incident_Substrate_Model/operator_grammar.md संशोधन: RTT/1 · कैनन संस्करण स्थिति: प्राधिकृत जारी किया गया: 2026-05-20

प्रस्तावना#

यह दस्तावेज़ घटना उपस्ट्रेट मॉडल (ISM) के लिए पूर्ण ऑपरेटर व्याकरण को परिभाषित करता है जो त्रैतीयक ढांचे के कैनन के भीतर है। सभी ऑपरेटर RTT/1 (पुनरावृत्त त्रैतीयक वर्गीकरण, संस्करण 1) प्रोटोकॉल के तहत निर्दिष्ट हैं।

RTT/1 व्याकरण सम्मेलन#

सम्मेलन अर्थ
OPERATOR पूर्ण-योग्य ऑपरेटर पहचानकर्ता डॉट-नेमस्पेस नोटेशन में
IN(...) आवश्यक इनपुट फ़ील्ड; टाइप किए गए और क्रमबद्ध
OUT(...) उत्सर्जित आउटपुट फ़ील्ड; टाइप किए गए और निश्चित
PRE[...] पूर्व-शर्त पूर्वानुमान — निष्पादन से पहले सभी को true का मूल्यांकन करना चाहिए
POST[...] पोस्ट-शर्त आश्वासन — निष्पादन के तुरंत बाद सभी को मान्य होना चाहिए
GUARD(...) ऑपरेटर-स्तरीय सुरक्षा गेट; विफलता ऑपरेटर को रोक देती है
YIELDS → सफलता पर उत्सर्जित टर्मिनल स्थिति संक्रमण
FAULTS → नामित दोष स्थितियाँ; प्रत्येक को कॉलिंग सब्स्ट्रेट द्वारा संभाला जाना चाहिए
MODE निष्पादन मोड: READONLY, MUTATING, या APPROVAL_GATED
IDEMPOTENT ऑपरेटर को बिना साइड-इफेक्ट संचय के सुरक्षित रूप से पुनः प्रयास किया जा सकता है

सभी ऑपरेटर निश्चित हैं: समान सब्स्ट्रेट स्थिति के तहत समान इनपुट को समान आउटपुट उत्पन्न करना चाहिए। गैर-निश्चितता एक व्याकरण दोष है।

READONLY से चिह्नित ऑपरेटर को किसी भी स्थायी सब्स्ट्रेट स्थिति को नहीं बदलना चाहिए। MUTATING से चिह्नित ऑपरेटर को POST[...] में सभी स्थिति संक्रमणों की घोषणा करनी चाहिए। APPROVAL_GATED से चिह्नित ऑपरेटर को GUARD(...) से आगे नहीं बढ़ना चाहिए जब तक कि IN(...) में एक अनुमोदन टोकन मौजूद न हो।

नेमस्पेस उपसर्ग incident. सभी ऑपरेटरों को ISM सब्स्ट्रेट पर सीमित करता है। उप-नेमस्पेस incident.execute.* केवल सीमित, उलटने योग्य-या-स्वीकृत निष्पादन ऑपरेटरों के लिए आरक्षित है।

1. ऑपरेटर परिवार: इनजेशन#

incident.ingest#

मोड: MUTATING · आइडेम्पोटेंट: हाँ (की signal_id पर आधारित)

उद्देश्य: किसी भी अपस्ट्रीम उत्सर्जक से एक कच्चा घटना संकेत स्वीकार करें और इसे एक मानक ISM IncidentRecord में सामान्यीकृत करें। यह सब्सट्रेट में बाहरी संकेत ट्रैफ़िक के लिए एकमात्र प्रवेश बिंदु है।

OPERATOR  incident.ingest

IN(
  signal_id      : UUID,          -- Emitter-assigned unique signal identifier
  source         : String,        -- Emitter identity (service name, sensor label, etc.)
  raw_payload    : Bytes,         -- Unprocessed signal body; encoding declared by content_type
  content_type   : MIME,          -- e.g. "application/json", "text/plain"
  emitted_at     : Timestamp,     -- Emitter-side emission time (UTC ISO-8601)
  severity_hint  : SeverityHint?  -- Optional emitter-declared severity; may be overridden downstream
)

OUT(
  record_id      : UUID,          -- ISM-assigned canonical record identifier
  ingested_at    : Timestamp,     -- Substrate-side ingestion time (UTC ISO-8601)
  status         : IngestionStatus -- ACCEPTED | DUPLICATE | REJECTED
)

PRE[
  signal_id is syntactically valid UUID,
  source is non-empty and registered in the emitter registry,
  raw_payload byte length > 0,
  content_type is a supported MIME type,
  emitted_at <= substrate_clock.now()
]

POST[
  status == ACCEPTED  →  IncidentRecord(record_id) exists in substrate with state = INGESTED,
  status == DUPLICATE →  no new record created; existing record_id returned,
  status == REJECTED  →  no record created; fault emitted
]

GUARD(
  emitter is authorized: source ∈ allowed_emitter_set,
  payload size <= MAX_PAYLOAD_BYTES
)

YIELDS  → INGESTED
FAULTS  → UNAUTHORIZED_EMITTER | PAYLOAD_TOO_LARGE | MALFORMED_SIGNAL | UNSUPPORTED_CONTENT_TYPE

2. ऑपरेटर परिवार: वर्गीकरण#

incident.classify#

मोड: MUTATING · आइडेम्पोटेंट: नहीं (वर्गीकरण विकसित हो सकता है; प्रत्येक कॉल का संस्करण होता है)

उद्देश्य: एक IncidentRecord को एक संरचित वर्गीकरण सौंपना। वर्गीकरण का संस्करण होता है — लगातार कॉल एक नया ClassificationVersion जोड़ते हैं बजाय इसके कि ओवरराइट करें, रिकॉर्ड पर पूर्ण वर्गीकरण इतिहास को संरक्षित करते हैं।

OPERATOR  incident.classify

IN(
  record_id      : UUID,          -- Target IncidentRecord
  classifier_id  : String,        -- Identity of the classifying agent or model
  category       : IncidentCategory,  -- Primary taxonomy node (e.g. SECRET_LEAK, DEPENDENCY_CVE)
  subcategory    : String?,        -- Optional free-form subcategory label
  confidence     : Float[0.0,1.0], -- Classifier confidence in this classification
  rationale      : String          -- Human-readable classification rationale
)

OUT(
  record_id      : UUID,
  classification_version : UInt,   -- Monotonically increasing version index on this record
  effective_at   : Timestamp
)

PRE[
  IncidentRecord(record_id) exists,
  IncidentRecord(record_id).state ∈ {INGESTED, CLASSIFIED, SURFACE_MAPPED},
  confidence ∈ [0.0, 1.0],
  rationale is non-empty
]

POST[
  IncidentRecord(record_id).classification == ClassificationVersion(classification_version),
  IncidentRecord(record_id).state == CLASSIFIED,
  classification_version == previous_version + 1
]

GUARD(
  classifier_id is registered,
  confidence >= MIN_CLASSIFICATION_CONFIDENCE  -- substrate-configured threshold
)

YIELDS  → CLASSIFIED
FAULTS  → RECORD_NOT_FOUND | INVALID_CATEGORY | CONFIDENCE_BELOW_THRESHOLD | INVALID_STATE_TRANSITION

3. ऑपरेटर परिवार: सतह मानचित्रण#

incident.map_surface_area#

मोड: MUTATING · आइडेम्पोटेंट: हाँ (की record_id + surface_snapshot_hash पर आधारित)

उद्देश्य: सभी सब्सट्रेट सतहों (फाइलें, रहस्य, निर्भरताएँ, सेवाएँ, कॉन्फ़िगरेशन) को सूचीबद्ध करना जो वर्गीकृत घटना को छूती हैं। सतह क्षेत्र मानचित्र सभी डाउनस्ट्रीम सुधार और निष्पादन ऑपरेटरों के लिए प्राधिकृत दायरा सीमा है।

OPERATOR  incident.map_surface_area

IN(
  record_id         : UUID,
  scanner_id        : String,               -- Identity of the surface scanner agent
  surfaces          : List<SurfaceEntry>,   -- See SurfaceEntry schema below
  surface_snapshot_hash : Hash              -- Content hash of the surfaces list for idempotency
)

-- SurfaceEntry schema:
--   surface_type   : SurfaceType  (FILE | SECRET | DEPENDENCY | SERVICE | CONFIG)
--   surface_ref    : String       (path, ARN, package@version, service name, config key)
--   access_mode    : AccessMode   (READ | WRITE | EXECUTE | UNKNOWN)
--   confidence     : Float[0.0,1.0]
--   notes          : String?

OUT(
  record_id         : UUID,
  surface_map_id    : UUID,       -- Stable identifier for this surface map snapshot
  surface_count     : UInt,
  mapped_at         : Timestamp
)

PRE[
  IncidentRecord(record_id) exists,
  IncidentRecord(record_id).state == CLASSIFIED,
  surfaces is non-empty,
  all surface_ref values are syntactically valid for their surface_type,
  surface_snapshot_hash == hash(surfaces)
]

POST[
  IncidentRecord(record_id).surface_map_id == surface_map_id,
  IncidentRecord(record_id).state == SURFACE_MAPPED,
  SurfaceMap(surface_map_id).entries.count == surface_count
]

GUARD(
  scanner_id is registered,
  surface_count <= MAX_SURFACE_ENTRIES  -- prevents unbounded scope creep
)

YIELDS  → SURFACE_MAPPED
FAULTS  → RECORD_NOT_FOUND | INVALID_STATE_TRANSITION | EMPTY_SURFACE_LIST
         | SURFACE_REF_INVALID | SURFACE_LIMIT_EXCEEDED | HASH_MISMATCH

4. ऑपरेटर परिवार: सुधार योजना#

incident.derive_rectification_steps#

मोड: MUTATING · आइडेम्पोटेंट: नहीं (चरण व्युत्पत्ति सतह मानचित्र के अनुसार संस्करणित है)

उद्देश्य: सतह क्षेत्र मानचित्र से rectification चरणों की एक क्रमबद्ध, सीमित सूची व्युत्पन्न करना। प्रत्येक चरण ठीक एक incident.execute.* ऑपरेटर से मेल खाता है। यह ऑपरेटर कुछ भी निष्पादित नहीं करता है - यह केवल एक प्रकार का, ऑपरेटर-बाउंड योजना उत्पन्न करता है।

OPERATOR  incident.derive_rectification_steps

IN(
  record_id      : UUID,
  surface_map_id : UUID,
  planner_id     : String,           -- Identity of the planning agent
  steps          : List<RectificationStep>  -- See RectificationStep schema below
)

-- RectificationStep schema:
--   step_index     : UInt          (0-based; must be unique and gapless)
--   operator_ref   : OperatorRef   (must resolve to an incident.execute.* operator)
--   target_ref     : String        (must exist in SurfaceMap(surface_map_id).entries)
--   parameters     : Map<String,Any>
--   reversible     : Bool
--   rationale      : String

OUT(
  record_id      : UUID,
  plan_id        : UUID,
  step_count     : UInt,
  derived_at     : Timestamp
)

PRE[
  IncidentRecord(record_id) exists,
  IncidentRecord(record_id).state == SURFACE_MAPPED,
  IncidentRecord(record_id).surface_map_id == surface_map_id,
  steps is non-empty,
  step indices are 0-based, unique, and gapless,
  all operator_ref values resolve to valid incident.execute.* operators,
  all target_ref values exist in SurfaceMap(surface_map_id).entries
]

POST[
  IncidentRecord(record_id).plan_id == plan_id,
  IncidentRecord(record_id).state == PLAN_DERIVED,
  RectificationPlan(plan_id).steps.count == step_count
]

GUARD(
  planner_id is registered,
  step_count <= MAX_PLAN_STEPS,
  all operator_ref values are within the incident.execute.* namespace only
)

YIELDS  → PLAN_DERIVED
FAULTS  → RECORD_NOT_FOUND | INVALID_STATE_TRANSITION | SURFACE_MAP_MISMATCH
         | STEP_INDEX_INVALID | UNKNOWN_OPERATOR_REF | TARGET_NOT_IN_SURFACE_MAP
         | PLAN_STEP_LIMIT_EXCEEDED

incident.generate_readonly_plan#

मोड: READONLY · आइडेम्पोटेंट: हाँ

उद्देश्य: वर्तमान RectificationPlan का एक मानव-पठनीय, केवल-पढ़ने योग्य प्रतिनिधित्व प्रस्तुत करना। यह ऑपरेटर किसी भी सब्सट्रेट स्थिति को संशोधित नहीं करता है। यह incident.request_operator_approval से पहले का मानक गेट है।

OPERATOR  incident.generate_readonly_plan

IN(
  record_id      : UUID,
  plan_id        : UUID,
  format         : PlanFormat   -- MARKDOWN | JSON | TEXT
)

OUT(
  record_id      : UUID,
  plan_id        : UUID,
  rendered_plan  : String,      -- Plan body in requested format; no executable content
  rendered_at    : Timestamp
)

PRE[
  IncidentRecord(record_id) exists,
  IncidentRecord(record_id).plan_id == plan_id,
  IncidentRecord(record_id).state ∈ {PLAN_DERIVED, PENDING_APPROVAL, APPROVED, HOLD},
  format ∈ {MARKDOWN, JSON, TEXT}
]

POST[
  no substrate state modified,
  rendered_plan is non-empty,
  rendered_plan contains no embedded operator invocations or executable directives
]

GUARD(
  rendered_plan must not contain control characters or script injection patterns
)

YIELDS  → (no state transition; read-only)
FAULTS  → RECORD_NOT_FOUND | PLAN_NOT_FOUND | PLAN_ID_MISMATCH | UNSUPPORTED_FORMAT

incident.flag_uncertainty#

मोड: MUTATING · आइडेम्पोटेंट: हाँ (की record_id + uncertainty_code पर आधारित)

उद्देश्य: जब सब्सट्रेट या एक योजना एजेंट के पास मानव समीक्षा के बिना आगे बढ़ने के लिए पर्याप्त विश्वास नहीं होता है, तो एक रिकॉर्ड पर एक संरचित अनिश्चितता एनोटेशन संलग्न करें। अनिश्चितता को चिह्नित करना रिकॉर्ड को अवरुद्ध नहीं करता है - यह अनुमोदन संदर्भ को समृद्ध करता है और वृद्धि रूटिंग को ट्रिगर कर सकता है।

OPERATOR  incident.flag_uncertainty

IN(
  record_id        : UUID,
  flagging_agent   : String,
  uncertainty_code : UncertaintyCode,  -- See UncertaintyCode registry below
  affected_field   : String?,          -- Optional pointer to the uncertain field or step
  detail           : String            -- Human-readable description of the uncertainty
)

-- UncertaintyCode registry:
--   CLASSIFICATION_AMBIGUOUS    -- Multiple categories plausible with similar confidence
--   SURFACE_INCOMPLETE          -- Scanner may have missed surfaces
--   STEP_REVERSIBILITY_UNKNOWN  -- Cannot confirm if a rectification step is reversible
--   AUTHORIZATION_AMBIGUOUS     -- Approver set is unclear
--   EXTERNAL_DEPENDENCY_UNKNOWN -- Third-party behavior required for rectification is unverified
--   OTHER                       -- Catch-all; detail is mandatory when used

OUT(
  record_id        : UUID,
  flag_id          : UUID,
  flagged_at       : Timestamp
)

PRE[
  IncidentRecord(record_id) exists,
  uncertainty_code ∈ UncertaintyCode registry,
  detail is non-empty,
  if uncertainty_code == OTHER then detail.length >= MIN_OTHER_DETAIL_LENGTH
]

POST[
  UncertaintyFlag(flag_id) attached to IncidentRecord(record_id),
  IncidentRecord(record_id).uncertainty_flags.count increased by 1
]

GUARD(
  flagging_agent is registered
)

YIELDS  → (no state transition; annotation only)
FAULTS  → RECORD_NOT_FOUND | UNKNOWN_UNCERTAINTY_CODE | EMPTY_DETAIL
         | INSUFFICIENT_OTHER_DETAIL

5. ऑपरेटर परिवार: स्वीकृति प्रवाह#

incident.request_operator_approval#

मोड: APPROVAL_GATED · MUTATING · इडेम्पोटेंट: नहीं

उद्देश्य: RectificationPlan के लिए मानव ऑपरेटर अनुमोदन औपचारिक रूप से अनुरोध करें। रिकॉर्ड को PENDING_APPROVAL में स्थानांतरित करता है और निर्धारित अनुमोदक को सूचित करता है। कोई incident.execute.* ऑपरेटर तब तक आगे नहीं बढ़ सकता जब तक कि यह अनुरोध संतुष्ट न हो जाए।

OPERATOR  incident.request_operator_approval

IN(
  record_id        : UUID,
  plan_id          : UUID,
  requesting_agent : String,
  approver_set     : List<ApproverRef>,  -- At least one approver required
  approval_policy  : ApprovalPolicy,    -- ANY_ONE | MAJORITY | ALL
  context_note     : String?            -- Optional note for the approver set
)

OUT(
  record_id        : UUID,
  approval_request_id : UUID,
  requested_at     : Timestamp,
  approver_count   : UInt
)

PRE[
  IncidentRecord(record_id) exists,
  IncidentRecord(record_id).plan_id == plan_id,
  IncidentRecord(record_id).state == PLAN_DERIVED,
  approver_set is non-empty,
  all ApproverRef values are resolvable in the approver registry,
  approval_policy ∈ {ANY_ONE, MAJORITY, ALL}
]

POST[
  IncidentRecord(record_id).state == PENDING_APPROVAL,
  IncidentRecord(record_id).approval_request_id == approval_request_id,
  approver_set notified via substrate notification channel
]

GUARD(
  requesting_agent is registered,
  plan_id refers to a non-empty, validated RectificationPlan,
  record has no open uncertainty flags with severity >= BLOCKING
    unless explicitly acknowledged in context_note
)

YIELDS  → PENDING_APPROVAL
FAULTS  → RECORD_NOT_FOUND | PLAN_NOT_FOUND | INVALID_STATE_TRANSITION
         | EMPTY_APPROVER_SET | UNKNOWN_APPROVER | BLOCKING_UNCERTAINTY_FLAGS
         | INVALID_APPROVAL_POLICY

incident.hold_for_review#

मोड: MUTATING · आइडेम्पोटेंट: हाँ (यदि कारण मौजूदा होल्ड से मेल खाता है तो होल्ड आइडेम्पोटेंट है)

उद्देश्य: एक रिकॉर्ड को HOLD स्थिति में रखना, सभी लंबित निष्पादन को निलंबित करना। एक होल्ड किसी भी समय PLAN_DERIVED के बाद लगाया जा सकता है। होल्ड को निष्पादन फिर से शुरू होने से पहले एक अधिकृत ऑपरेटर द्वारा स्पष्ट रूप से जारी किया जाना चाहिए। यह ऑपरेटर ISM अनुमोदन प्रवाह में प्राथमिक सुरक्षा ब्रेक है।

OPERATOR  incident.hold_for_review

IN(
  record_id    : UUID,
  held_by      : String,      -- Identity of the hold-placing operator or agent
  reason_code  : HoldReason,  -- See HoldReason registry below
  detail       : String,      -- Mandatory detail regardless of reason_code
  resume_after : Timestamp?   -- Optional: earliest time hold may be lifted
)

-- HoldReason registry:
--   MANUAL_REVIEW_REQUESTED
--   BLOCKING_UNCERTAINTY
--   APPROVAL_DISPUTED
--   EXTERNAL_DEPENDENCY_PENDING
--   POLICY_ESCALATION
--   SUBSTRATE_FAULT

OUT(
  record_id   : UUID,
  hold_id     : UUID,
  held_at     : Timestamp,
  prior_state : RecordState   -- State the record was in before hold
)

PRE[
  IncidentRecord(record_id) exists,
  IncidentRecord(record_id).state ∈ {PLAN_DERIVED, PENDING_APPROVAL, APPROVED},
  reason_code ∈ HoldReason registry,
  detail is non-empty
]

POST[
  IncidentRecord(record_id).state == HOLD,
  IncidentRecord(record_id).hold_id == hold_id,
  HoldRecord(hold_id).prior_state == prior_state,
  all queued incident.execute.* steps for record_id are suspended
]

GUARD(
  held_by is authorized to place holds on this record
)

YIELDS  → HOLD
FAULTS  → RECORD_NOT_FOUND | INVALID_STATE_TRANSITION | UNKNOWN_HOLD_REASON
         | HOLD_UNAUTHORIZED | EMPTY_DETAIL

6. ऑपरेटर परिवार: सीमित निष्पादन#

सभी incident.execute.* ऑपरेटर इन अपरिवर्तनीयताओं को साझा करते हैं:

निष्पादन अपरिवर्तनीयताएँ (इस परिवार के सभी ऑपरेटरों पर लागू)

  1. लक्ष्य SurfaceMap के माता-पिता IncidentRecord में होना चाहिए।
  2. माता-पिता रिकॉर्ड को APPROVED स्थिति में होना चाहिए।
  3. कोई भी निष्पादन ऑपरेटर अनुमोदित RectificationPlan में घोषित दायरे से अधिक नहीं जा सकता।
  4. प्रत्येक निष्पादन ऑपरेटर पूर्णता पर एक अपरिवर्तनीय ExecutionRecord उत्पन्न करता है (सफलता या दोष)।
  5. दोषपूर्ण निष्पादन को लक्ष्यों को आंशिक रूप से संशोधित स्थिति में छोड़ने की अनुमति नहीं है बिना PARTIAL_EXECUTION दोष उत्पन्न किए।
  6. reversible: false चरणों वाले ऑपरेटरों को निष्पादन समय पर स्पष्ट चरण-स्तरीय पुनः-स्वीकृति की आवश्यकता होती है।

incident.execute.remove_file#

मोड: MUTATING · आइडेम्पोटेंट: हाँ (यदि फ़ाइल अनुपस्थित है, तो ALREADY_ABSENT की रिपोर्ट करता है)

उद्देश्य: सतह क्षेत्र मानचित्र में घोषित एक विशिष्ट फ़ाइल को हटाना। हटाना अपरिवर्तनीय रूप से लॉग किया जाता है। फ़ाइल पथ को स्वीकृत योजना में FILE-प्रकार के सतह प्रविष्टि से सटीक मेल खाना चाहिए।

OPERATOR  incident.execute.remove_file

IN(
  record_id     : UUID,
  plan_id       : UUID,
  step_index    : UInt,
  file_path     : String,       -- Absolute canonical path; must match surface entry exactly
  checksum      : Hash?,        -- Optional pre-removal checksum for audit
  dry_run       : Bool          -- If true, validate only; do not remove
)

OUT(
  record_id      : UUID,
  execution_id   : UUID,
  status         : ExecutionStatus,  -- REMOVED | ALREADY_ABSENT | DRY_RUN_OK
  removed_at     : Timestamp?,
  prior_checksum : Hash?
)

PRE[
  IncidentRecord(record_id).state == APPROVED,
  IncidentRecord(record_id).plan_id == plan_id,
  RectificationPlan(plan_id).steps[step_index].operator_ref == "incident.execute.remove_file",
  RectificationPlan(plan_id).steps[step_index].target_ref == file_path,
  file_path ∈ SurfaceMap(IncidentRecord(record_id).surface_map_id) with surface_type == FILE
]

POST[
  dry_run == false AND status == REMOVED →
    file at file_path no longer exists,
    ExecutionRecord(execution_id) created with status REMOVED,
  dry_run == true →
    no filesystem state changed,
    ExecutionRecord(execution_id) created with status DRY_RUN_OK
]

GUARD(
  executor has filesystem write access to file_path,
  file_path does not resolve outside declared substrate boundaries (no path traversal)
)

YIELDS  → STEP_EXECUTED
FAULTS  → RECORD_NOT_FOUND | PLAN_STEP_MISMATCH | FILE_NOT_IN_SURFACE_MAP
         | ACCESS_DENIED | PATH_TRAVERSAL_DETECTED | PARTIAL_EXECUTION
         | CHECKSUM_MISMATCH

incident.execute.rotate_secret#

मोड: MUTATING · आइडेम्पोटेंट: नहीं (प्रत्येक घुमाव एक नया रहस्य संस्करण उत्पन्न करता है)

उद्देश्य: एक रहस्य (API कुंजी, क्रेडेंशियल, टोकन, प्रमाणपत्र) को घुमाना जो सतह क्षेत्र मानचित्र में घोषित किया गया है। पुरानी रहस्य मान अमान्य हो जाती है और नई मान को उपस्ट्रेट के रहस्य प्रबंधन परत के माध्यम से संग्रहीत किया जाता है। नई रहस्य मान कभी भी OUT में नहीं निकाली जाती है।

OPERATOR  incident.execute.rotate_secret

IN(
  record_id         : UUID,
  plan_id           : UUID,
  step_index        : UInt,
  secret_ref        : String,         -- ARN, vault path, or secret identifier; must match surface entry
  rotation_policy   : RotationPolicy, -- IMMEDIATE | SCHEDULED
  notify_dependents : Bool            -- If true, substrate notifies registered secret consumers
)

OUT(
  record_id          : UUID,
  execution_id       : UUID,
  status             : ExecutionStatus,  -- ROTATED | SCHEDULED
  new_secret_version : String,           -- Version identifier only; NOT the secret value
  rotated_at         : Timestamp?
)

PRE[
  IncidentRecord(record_id).state == APPROVED,
  IncidentRecord(record_id).plan_id == plan_id,
  RectificationPlan(plan_id).steps[step_index].operator_ref == "incident.execute.rotate_secret",
  RectificationPlan(plan_id).steps[step_index].target_ref == secret_ref,
  secret_ref ∈ SurfaceMap(IncidentRecord(record_id).surface_map_id) with surface_type == SECRET,
  rotation_policy ∈ {IMMEDIATE, SCHEDULED}
]

POST[
  status == ROTATED →
    old secret version invalidated in secret management layer,
    new_secret_version active,
    notify_dependents == true → dependent consumers notified,
  ExecutionRecord(execution_id) created,
  new secret value never stored in ExecutionRecord or any ISM log
]

GUARD(
  executor has secret rotation authorization for secret_ref,
  new secret value is never written to OUT or any audit log (zero-secret-value guarantee)
)

YIELDS  → STEP_EXECUTED
FAULTS  → RECORD_NOT_FOUND | PLAN_STEP_MISMATCH | SECRET_NOT_IN_SURFACE_MAP
         | ROTATION_UNAUTHORIZED | ROTATION_PROVIDER_ERROR | PARTIAL_EXECUTION
         | DEPENDENT_NOTIFICATION_FAILED

incident.execute.patch_dependency#

मोड: MUTATING · आइडेम्पोटेंट: हाँ (की record_id + package_ref + target_version पर आधारित)

उद्देश्य: एक निर्भरता पैच लागू करें - एक पैकेज को घोषित लक्ष्य संस्करण में अपग्रेड या पिन करना। निर्भरता को सतह क्षेत्र मानचित्र में DEPENDENCY-प्रकार की सतह प्रविष्टि के रूप में घोषित किया जाना चाहिए। पैच आवेदन के बाद एक निश्चित सत्यापन चरण होता है।

OPERATOR  incident.execute.patch_dependency

IN(
  record_id       : UUID,
  plan_id         : UUID,
  step_index      : UInt,
  package_ref     : String,          -- Package identifier, e.g. "npm:lodash" or "pypi:requests"
  current_version : String,          -- Version being replaced; must match installed version
  target_version  : String,          -- Version to install; must be a known-good release
  package_manager : PackageManager,  -- NPM | PIP | CARGO | MAVEN | GRADLE | OTHER
  verify_checksum : Hash?,           -- Optional expected checksum of target package
  dry_run         : Bool
)

OUT(
  record_id       : UUID,
  execution_id    : UUID,
  status          : ExecutionStatus,  -- PATCHED | DRY_RUN_OK | ALREADY_AT_TARGET
  patched_version : String?,
  patched_at      : Timestamp?
)

PRE[
  IncidentRecord(record_id).state == APPROVED,
  IncidentRecord(record_id).plan_id == plan_id,
  RectificationPlan(plan_id).steps[step_index].operator_ref == "incident.execute.patch_dependency",
  RectificationPlan(plan_id).steps[step_index].target_ref == package_ref,
  package_ref ∈ SurfaceMap(IncidentRecord(record_id).surface_map_id) with surface_type == DEPENDENCY,
  current_version is semver-valid,
  target_version is semver-valid,
  target_version > current_version OR target_version is an explicit pinned release
]

POST[
  dry_run == false AND status == PATCHED →
    package at package_ref upgraded to target_version,
    verify_checksum provided → checksum verified against installed package,
    ExecutionRecord(execution_id) created,
  dry_run == true →
    no package state changed,
    ExecutionRecord(execution_id) created with DRY_RUN_OK
]

GUARD(
  executor has write access to the dependency manifest and lock file,
  target_version is not marked deprecated or yanked in package_manager registry,
  verify_checksum provided → checksum must match before activation
)

YIELDS  → STEP_EXECUTED
FAULTS  → RECORD_NOT_FOUND | PLAN_STEP_MISMATCH | DEPENDENCY_NOT_IN_SURFACE_MAP
         | VERSION_MISMATCH | TARGET_VERSION_INVALID | PACKAGE_MANAGER_ERROR
         | CHECKSUM_MISMATCH | PARTIAL_EXECUTION

incident.execute.flag_for_followup#

मोड: MUTATING · आइडेम्पोटेंट: हाँ (की record_id + followup_code पर आधारित)

उद्देश्य: एक सतह प्रविष्टि या योजना चरण को चिह्नित करें जो घटना के बाद की अनुवर्ती कार्रवाई की आवश्यकता है जिसे वर्तमान सुधार विंडो के भीतर पूरा नहीं किया जा सकता। यह ऑपरेटर चरण को बंद कर देता है बिना लक्ष्य को परिवर्तित किए, सब्सट्रेट के ट्रैकिंग परत में एक संरचित अनुवर्ती टिकट उत्पन्न करता है।

OPERATOR  incident.execute.flag_for_followup

IN(
  record_id       : UUID,
  plan_id         : UUID,
  step_index      : UInt,
  target_ref      : String,           -- Surface entry or step reference being deferred
  followup_code   : FollowupCode,     -- See FollowupCode registry below
  priority        : FollowupPriority, -- CRITICAL | HIGH | MEDIUM | LOW
  assigned_to     : List<String>,     -- Assignee identifiers; at least one required
  due_by          : Timestamp?,       -- Optional deadline
  detail          : String            -- Mandatory description of follow-up action required
)

-- FollowupCode registry:
--   MANUAL_REMEDIATION_REQUIRED     -- Step requires human action beyond substrate capability
--   THIRD_PARTY_COORDINATION        -- Remediation depends on external party
--   DEFERRAL_APPROVED               -- Approved deferral; reason documented in detail
--   RISK_ACCEPTED                   -- Risk explicitly accepted; documented in detail
--   MONITORING_REQUIRED             -- No action now; ongoing monitoring required

OUT(
  record_id    : UUID,
  execution_id : UUID,
  followup_id  : UUID,            -- Tracking ticket identifier
  status       : ExecutionStatus, -- FLAGGED
  flagged_at   : Timestamp
)

PRE[
  IncidentRecord(record_id).state == APPROVED,
  IncidentRecord(record_id).plan_id == plan_id,
  RectificationPlan(plan_id).steps[step_index].operator_ref == "incident.execute.flag_for_followup",
  followup_code ∈ FollowupCode registry,
  priority ∈ {CRITICAL, HIGH, MEDIUM, LOW},
  assigned_to is non-empty,
  detail is non-empty
]

POST[
  FollowupTicket(followup_id) created in substrate tracking layer,
  FollowupTicket(followup_id).assigned_to == assigned_to,
  ExecutionRecord(execution_id) created with status FLAGGED,
  step_index marked FLAGGED_FOR_FOLLOWUP in RectificationPlan(plan_id)
]

GUARD(
  all assigned_to identifiers resolvable in operator registry,
  if followup_code == RISK_ACCEPTED →
    detail.length >= MIN_RISK_ACCEPTANCE_DETAIL_LENGTH
)

YIELDS  → STEP_EXECUTED
FAULTS  → RECORD_NOT_FOUND | PLAN_STEP_MISMATCH | UNKNOWN_FOLLOWUP_CODE
         | INVALID_PRIORITY | EMPTY_ASSIGNEE_LIST | UNRESOLVABLE_ASSIGNEE
         | INSUFFICIENT_RISK_DETAIL | EMPTY_DETAIL

7. राज्य मशीन#

मानक ISM रिकॉर्ड राज्य मशीन कानूनी राज्य संक्रमणों को नियंत्रित करती है। केवल नीचे सूचीबद्ध संक्रमण ही मान्य हैं; अन्य सभी व्याकरण दोष हैं।

INGESTED
  → CLASSIFIED            via  incident.classify
  → HOLD                  via  incident.hold_for_review

CLASSIFIED
  → SURFACE_MAPPED        via  incident.map_surface_area
  → CLASSIFIED            via  incident.classify            (re-classification; version++)
  → HOLD                  via  incident.hold_for_review

SURFACE_MAPPED
  → PLAN_DERIVED          via  incident.derive_rectification_steps
  → CLASSIFIED            via  incident.classify            (reclassify; resets to CLASSIFIED)
  → HOLD                  via  incident.hold_for_review

PLAN_DERIVED
  → PENDING_APPROVAL      via  incident.request_operator_approval
  → HOLD                  via  incident.hold_for_review

PENDING_APPROVAL
  → APPROVED              via  [approval resolution: external to grammar]
  → PLAN_DERIVED          via  [approval rejection: external to grammar]
  → HOLD                  via  incident.hold_for_review

HOLD
  → [prior_state]         via  [hold release: external to grammar; restores prior_state]

APPROVED
  → EXECUTING             via  [first incident.execute.* invocation]
  → HOLD                  via  incident.hold_for_review

EXECUTING
  → RESOLVED              via  [all plan steps STEP_EXECUTED or FLAGGED_FOR_FOLLOWUP]
  → HOLD                  via  incident.hold_for_review
  → FAULTED               via  [any PARTIAL_EXECUTION fault on any step]

RESOLVED   -- Terminal: no further state transitions permitted
FAULTED    -- Terminal: requires manual intervention; may spawn new record via incident.ingest

8. प्रकार रजिस्ट्रि#

UUID              ::= RFC 4122 v4 UUID string
Timestamp         ::= ISO-8601 UTC datetime string, precision to milliseconds
Hash              ::= SHA-256 hex digest string (64 hex characters)
MIME              ::= IANA-registered MIME type string
SeverityHint      ::= CRITICAL | HIGH | MEDIUM | LOW | UNKNOWN
IncidentCategory  ::= SECRET_LEAK | DEPENDENCY_CVE | MISCONFIGURATION | UNAUTHORIZED_ACCESS
                    | DATA_EXPOSURE | SUPPLY_CHAIN | POLICY_VIOLATION | UNKNOWN
SurfaceType       ::= FILE | SECRET | DEPENDENCY | SERVICE | CONFIG
AccessMode        ::= READ | WRITE | EXECUTE | UNKNOWN
IngestionStatus   ::= ACCEPTED | DUPLICATE | REJECTED
ExecutionStatus   ::= REMOVED | ROTATED | PATCHED | FLAGGED | ALREADY_ABSENT
                    | ALREADY_AT_TARGET | DRY_RUN_OK | SCHEDULED
RecordState       ::= INGESTED | CLASSIFIED | SURFACE_MAPPED | PLAN_DERIVED
                    | PENDING_APPROVAL | APPROVED | EXECUTING | HOLD | RESOLVED | FAULTED
PlanFormat        ::= MARKDOWN | JSON | TEXT
ApprovalPolicy    ::= ANY_ONE | MAJORITY | ALL
PackageManager    ::= NPM | PIP | CARGO | MAVEN | GRADLE | OTHER
FollowupPriority  ::= CRITICAL | HIGH | MEDIUM | LOW
OperatorRef       ::= Fully-qualified dot-namespace string resolving to an incident.execute.* operator
ApproverRef       ::= Opaque string resolvable in the approver registry

9. सब्सट्रेट स्थिरांक#

ये मान सब्सट्रेट-कॉन्फ़िगर किए गए हैं और इन्हें ISM कॉन्फ़िगरेशन परत के माध्यम से ओवरराइड किया जाना चाहिए, ऑपरेटर कार्यान्वयन में हार्डकोड नहीं किया जाना चाहिए।

स्थिरांक डिफ़ॉल्ट विवरण
MAX_PAYLOAD_BYTES 10 485 760 (10 MiB) इंजेशन के लिए अधिकतम raw_payload आकार
MIN_CLASSIFICATION_CONFIDENCE 0.70 वर्गीकरण को आगे बढ़ाने के लिए न्यूनतम विश्वास
MAX_SURFACE_ENTRIES 500 प्रति सतह मानचित्र अधिकतम सतह प्रविष्टियाँ
MAX_PLAN_STEPS 50 प्रति योजना अधिकतम सुधार कदम
MIN_OTHER_DETAIL_LENGTH 80 वर्ण जब UncertaintyCode OTHER हो तो न्यूनतम विवरण लंबाई
MIN_RISK_ACCEPTANCE_DETAIL_LENGTH 150 वर्ण RISK_ACCEPTED फॉलो-अप ध्वजों के लिए न्यूनतम विवरण

10. व्याकरण अपरिवर्तनीयताएँ#

निम्नलिखित अपरिवर्तनीयताएँ पूरे ISM ऑपरेटर व्याकरण में लागू होती हैं। किसी भी अपरिवर्तनीयता का उल्लंघन एक उपस्ट्रेट दोष है, न कि एक ऑपरेटर दोष।

  1. नेमस्पेस पृथक्करण: incident.* नेमस्पेस के बाहर कोई भी ऑपरेटर IncidentRecord को संशोधित नहीं कर सकता।
  2. योजना अपरिवर्तनीयता: एक RectificationPlan अपरिवर्तनीय है जब PENDING_APPROVAL में प्रवेश किया जाता है। पुनः योजना बनाने के लिए PLAN_DERIVED पर लौटना आवश्यक है, जो अनुमोदन अस्वीकृति के माध्यम से होता है।
  3. सतह दायरा प्रवर्तन: incident.execute.* ऑपरेटर केवल उन लक्ष्यों पर कार्य कर सकते हैं जो अनुमोदित SurfaceMap में घोषित किए गए हैं। दायरे से बाहर के लक्ष्य एक व्याकरण दोष हैं।
  4. शून्य गुप्त मूल्य गारंटी: गुप्त मूल्य कभी भी किसी OUT, ExecutionRecord, लॉग, या ऑडिट ट्रेल में नहीं दिखाई देने चाहिए। संस्करण पहचानकर्ता और संदर्भ की अनुमति है।
  5. कार्य निष्पादन अनुक्रम: incident.execute.* चरणों को step_index क्रम में निष्पादित किया जाना चाहिए जब तक कि RectificationPlan स्पष्ट समानांतर समूहों की घोषणा न करे। डिफ़ॉल्ट रूप से यह सख्त अनुक्रमिक है।
  6. अनुमोदन गेट: कोई incident.execute.* ऑपरेटर तब तक शुरू नहीं कर सकता जब तक कि IncidentRecord.state == APPROVED और approval_request_id रिकॉर्ड पर मौजूद न हो।
  7. अनिश्चितता ध्वज वृद्धि: BLOCKING गंभीरता के साथ अनिश्चितता ध्वज को incident.request_operator_approval आगे बढ़ने से पहले हल या स्पष्ट रूप से स्वीकार किया जाना चाहिए।
  8. होल्ड सर्वोच्चता: HOLD स्थिति में एक रिकॉर्ड के खिलाफ कोई incident.execute.* ऑपरेटर नहीं लगाया जा सकता, चाहे अनुमोदन स्थिति कुछ भी हो।
  9. टर्मिनल स्थिति अंतिमता: RESOLVED या FAULTED स्थितियों में रिकॉर्ड अपरिवर्तनीय होते हैं। नए घटना संकेतों को नए रिकॉर्ड के रूप में incident.ingest के माध्यम से प्रवेश करना चाहिए।
  10. निर्धारण आवश्यकता: सभी ऑपरेटरों को समान उपस्ट्रेट स्थिति के तहत समान OUT उत्पन्न करना चाहिए। कोई भी ऑपरेटर जो गैर-निर्धारण प्रदर्शित करता है, वह एक व्याकरण दोष है।

ऑपरेटर व्याकरण दस्तावेज़ का अंत। कैनोनिकल स्रोत: /docs/Incident_Substrate_Model/operator_grammar.md · त्रैतीयक ढांचे का भंडार RTT/1 कैनन · ISM व्याकरण v1.0

क्या शामिल है: 6 परिवारों में सभी 12 ऑपरेटर, 10-राज्य निर्धारक रिकॉर्ड स्थिति मशीन, एक पूर्ण प्रकार रजिस्ट्र्री, उपस्ट्रेट स्थिरांक तालिका, और 10 क्रॉस-कटिंग व्याकरण अपरिवर्तनीयताएँ — सभी RTT/1 OPERATOR / IN / OUT / PRE / POST / GUARD / YIELDS / FAULTS रूप में।

द्वारा संचालित Docsbook