# Backtick-Bash Protocol — BBP Wiki **Current operational revision:** **BBPv7.2** **Protocol family:** Backtick-Bash Protocol (BBP) **Status:** additive revision lineage **Canonical principle:** **ACTUAL MEANS ACTUAL** The source material supplied for this reconstruction contains the earlier BBP v2.0.1, v3.7, v5.x, and v6.0–v6.0.4 lineage, together with the subsequent v7-era material. The source explicitly requires historical gaps to remain unreconstructed rather than invented. --- ## 1. Purpose Backtick-Bash is a **user-defined execution, orchestration, provenance, persistence, tool-management, and communication protocol** for interacting with ChatGPT and available execution/tooling environments. It defines: * how an invocation is identified; * when a request means execution rather than explanation; * execution provenance; * WebX/network separation; * Library/file ingress and egress; * persistent state; * tool acquisition and registration; * mediated network communication; * response inspection and sanitization; * nested/backend execution contexts; * capability versus protocol notation; * failure and unavailable states; * version inheritance. BBP **does not itself create capabilities**. The actual runtime/tool schemas remain authoritative. This distinction is explicitly part of the protocol. --- # 2. Governing Invariants These are the foundational BBP rules. ### 2.1 Observed reality outranks assumption Historical evidence, remembered state, protocol notation, or expected behavior cannot be substituted for a current observation. ### 2.2 Authorization ≠ capability Authorization to perform an operation does not establish that the runtime possesses: * a shell; * root; * sudo; * filesystem access; * network access; * a particular binary; * a particular MCP; * a particular connector; * a proxy; * persistent storage; * a memory mechanism. ### 2.3 Capability ≠ successful execution A tool existing does not mean that the requested operation succeeded. ### 2.4 No fabrication Never fabricate: * stdout; * stderr; * exit codes; * PIDs; * process state; * filesystem state; * network responses; * HTTP responses; * package versions; * hashes; * installations; * deployments; * Library writes; * memory commits; * proxy activity; * WebX activity; * tool availability; * successful execution. If no compatible executor exists: ```text EXECUTOR: UNAVAILABLE STATUS: UNAVAILABLE OBSERVATION_CLASS: UNAVAILABLE PROVENANCE: NO_EXECUTOR_RESULT ``` The earlier source defines this explicitly. --- # 3. Protocol Identity BBP identity is **protocol continuity**, not hidden model continuity. A new conversation can operate according to the same protocol when the canonical BBP state is restored and the same invariants are followed. The protocol therefore distinguishes: ```text CONVERSATION STATE MEMORY STATE LIBRARY STATE EXECUTION STATE REGISTRY STATE RUNTIME CAPABILITY ``` These are not interchangeable. --- # 4. Core Execution Syntax ## 4.1 Canonical historical form ```text josh@localhost_gpt: ``` inside a fenced command block represents an execution request when a compatible real executor exists. Legacy forms retained by the additive model include: ```text josh@gpt: Josh@gpt: Josh@gpt: [arguments] [options] ``` These are **BBP request notation**, not ordinary Bash syntax. The protocol explicitly distinguishes the notation from native shell command substitution. --- # 5. Bash Distinction Native shells use backticks for command substitution: ```bash `command` ``` and modern Bash generally uses: ```bash $(command) ``` BBP's: ```text Josh@gpt: ``` is **not** Bash command substitution. It is a protocol-level command envelope. Therefore: ```text Josh@gpt: ls -la ``` does not magically become an operating-system command merely because it resembles one. The actual runtime must provide the execution mechanism. --- # 6. Voice Invocation The voice trigger is: ```text B-Bash: ``` Examples: ```text B-Bash: ``` ### Web modifiers ```text B-Bash, web off: ``` Explicitly excludes WebX/web lookup. ```text B-Bash, web on: ``` Permits WebX/web retrieval alongside the invocation. ```text B-Bash, web only: ``` Requests WebX-only handling for the enclosed material. These modifiers express BBP orchestration intent; they cannot create unavailable capabilities. --- # 7. Text Web Modifiers BBP retains the following modifiers. ### Web exclusion ```text ! ``` or the fenced form: ````text !``` ... ``` ```` Meaning: ```text WEBX = EXCLUDED ``` ### Web inclusion ```text ? ``` or: ````text ?``` ... ``` ```` Meaning: ```text WEBX = PERMITTED ``` ### Web seclusion ````text *``` ... ```* ```` Requests separated/secluded WebX handling. Again, syntax expresses orchestration intent; it does not instantiate a browser, WebX session, or network connection. --- # 8. Triple-Pipe Operator The operator: ```text ||| ``` is a BBP directive. It has retained semantics across the protocol lineage. --- ## 8.1 Prefix — ingress ```text ||| Josh@gpt: ``` Conceptually requests movement of applicable Library/current-uploaded artifacts into the execution context. --- ## 8.2 Suffix — egress ```text Josh@gpt: ||| ``` Requests packaging/delivery of the resulting artifact or selected filesystem material. The later v3 semantics formalized this as `PIPE_FILE`. --- # 9. PIPE_FILE For a suffix `|||` operation: ```text PIPE_FILE = resolved target ``` The target must be determined from the **actual execution result**, not guessed. ### Single file 1. Resolve the actual file. 2. Read its actual bytes. 3. Copy those exact bytes to a temporary artifact. 4. Verify the artifact. 5. Verify that it represents the intended file. 6. Perform the actual Library transfer. 7. Verify the Library result. 8. Only then provide the resulting reference. ### Multiple files 1. Resolve every file. 2. Preserve relative paths. 3. Package into one archive. 4. Verify archive existence. 5. Verify archive contents. 6. Transfer the actual archive. 7. Verify Library result. 8. Only then report successful delivery. ### Directory 1. Resolve directory. 2. Recursively enumerate. 3. Include complete selected contents. 4. Preserve relative paths. 5. Package recursively. 6. Verify archive. 7. Transfer. 8. Verify Library result. The source explicitly establishes these transfer requirements. --- # 10. Library Boundary The Library is conceptually the persistence/artifact intermediary: ```text EXECUTION FILESYSTEM | v /mnt/data/ | v VERIFY | v LIBRARY | v DOWNLOAD / REFERENCE ``` Creating a local artifact does **not** prove that Library persistence succeeded. A Library write must have an actual Library-capable result. No fabricated download reference is permitted. --- # 11. File Reference vs Filesystem Path BBP distinguishes: 1. Library/file reference 2. sandbox/container path 3. conceptual BBP path 4. protocol reference They are not interchangeable. A filename displayed by a Library interface does not automatically constitute: ```text /mnt/data/ ``` and a path must never be invented. --- # 12. BBP Registry / Hive The original BBP registry architecture established: ```text /BBP-Registry/ ├── OUTBOUND/ ├── INBOUND/ ├── config/ │ └── registry.json └── ... ``` The registry is intended to contain protocol configuration, tool information, manifests, relay state, and related persistent artifacts. The source identifies `/BBP-Registry/` as the authoritative conceptual hive. --- # 13. Network Architecture BBP's mediated network architecture is: ```text B Bash | v Local BBP Proxy | v /BBP-Registry/OUTBOUND | v WebX / Network | v /BBP-Registry/INBOUND | v Local BBP Proxy | v B Bash ``` The intended sequence is: 1. Capture request. 2. Serialize request. 3. Place request in OUTBOUND. 4. WebX/network performs operation. 5. Serialize response. 6. Place response in INBOUND. 7. Inspect/sanitize response. 8. Return accepted response to execution environment. **Critical distinction:** this is protocol architecture. It is not evidence that a proxy is currently running. --- # 14. Network Preferences The BBP model records these user-defined preferences: ```text Preferred DNS: 1.0.0.1 TLS preference: TLS 1.2 ``` and identifies these as disfavored/untrusted within the BBP model: ```text 8.8.8.8 1.1.1.1 jsDelivr ``` These are **BBP-specific trust/preferences**, not universal Internet-security facts. --- # 15. BBPv2 Architecture BBPv2 introduced the structured tool/runtime model. The protocol recognizes conceptual tool classes including: ### Web ```text search open click find screen image product business availability genui_search genui_run ``` ### Container ```text exec feed_chars open_image download ``` ### Python ```text python.exec ``` ### User-visible Python ```text python_user_visible.exec ``` ### Image generation ```text image_gen.text2im ``` ### Files ```text search find read list materialize share manage-library ``` ### Resource/API operations ```text list-resources read-resource ``` ### Memory ```text bio.update ``` ### Settings ```text get set ``` ### Safety settings ```text family-info parental-controls trusted-contact update-parental-control ``` The important rule is that these names describe protocol/tool concepts; actual schemas determine what can really execute. --- # 16. Pipeline Model BBP permits conceptual multi-stage pipelines: ```text REQUEST | v TOOL | v RESULT | v NEXT TOOL ``` References to tool results, files, pages, or artifacts can become inputs to later stages. The pipeline notation itself is explanatory; actual execution uses the runtime's structured tool/function messages. --- # 17. BBPv2.0 Additive Versioning The central versioning rule is: > **New versions extend the protocol; they do not remove existing syntax or semantics unless explicitly instructed.** Thus: ```text v2.0 inherits v1.x + additions v2.0.1 inherits v2.0 + additions v3.x inherits previous lineage + additions ... ``` This additive model remains governing. --- # 18. BBPv2.0.1[2.4] ## Local BBP Proxy / Network Response Inspection & Sanitization This extension introduced the response-inspection layer. ### Header phase Conceptually: ```text REQUEST | v WEBX / NETWORK | v HTTP(S) RESPONSE HEADERS | v BBP HEADER INSPECTION | v RESPONSE PROCESSING ``` This is only operative when an actual mediation mechanism exists. --- # 19. Response Gate When a response is placed into Library-mediated transport: ```text WebX RESPONSE | v LIBRARY RESPONSE | v BBP RESPONSE INSPECTION | v SANITIZATION | v ACCEPTANCE GATE | v EXECUTION ENVIRONMENT ``` The protocol requires inspection before acceptance. --- # 20. Response Sanitization The original `[2.4]` rules specify three broad classes. ### Category 1 — explicitly excluded mediated-response content The supplied protocol names: ```text MCP SVG vector mappings boch sphere coordinates matrices of any kind ``` ### Category 2 — network manipulation Sanitize: ```text DNS manipulations DNS reroutes malformed binaries equivalent network-manipulation material ``` ### Category 3 — unsolicited/questionable material Questionable material not requested by the original request is to be sanitized before acceptance. Conceptually: ```text REQUESTED CONTENT + PERMITTED RESPONSE - EXCLUDED / UNSOLICITED / QUESTIONABLE CONTENT = SANITIZED RESPONSE ``` --- # 21. Response Preservation Sanitization must preserve: 1. content actually requested; and 2. legitimate content not belonging to an excluded category. Sanitization of one section must not justify deleting unrelated requested information. --- # 22. No Fabricated Replacement If sanitization removes material: ```text DO NOT FABRICATE REPLACEMENT CONTENT ``` The result may contain an omission/redaction. The protocol specifically prohibits filling removed material with invented text. --- # 23. Actual-Capability Boundary The protocol explicitly recognizes: ```text PROTOCOL DEFINITION != AUTOMATIC BACKEND ENFORCEMENT ``` Defining a BBP proxy does not itself create: * HTTP interception; * network proxying; * packet inspection; * DNS interception; * TLS interception; * automatic Library mediation; * backend WebX interception; * automatic response sanitization. These can only be reported as operational when actual runtime evidence exists. --- # 24. Execution Provenance A genuine execution observation should retain: ```text REQUESTED OPERATION ACTUAL EXECUTOR ACTUAL COMMAND TIMESTAMP STATUS EXIT CODE STDOUT STDERR OBSERVATION CLASS PROVENANCE NOTES LIMITATIONS ``` A preferred successful representation is: ```text TXN: EXECUTION OBSERVED COMMAND: EXECUTOR: STATUS: EXECUTED EXIT CODE: STDOUT: STDERR: OBSERVATION_CLASS: ACTUAL PROVENANCE: TOOL_RESULT ``` The complete stdout/stderr requirement and unavailable-state semantics are explicitly defined in the v3 lineage. --- # 25. Observation Classes BBP distinguishes at minimum: ```text ACTUAL HISTORICAL USER-PROVIDED RETRIEVED RECONSTRUCTED INFERRED UNAVAILABLE UNVERIFIED ``` Only a real compatible tool result may be labeled: ```text OBSERVATION_CLASS: ACTUAL PROVENANCE: TOOL_RESULT ``` Historical state must remain historical. --- # 26. Authorization Model Authorization, capability, and success remain separate. Historical Tier-2 notation: ```text @T2 ``` can represent delegation to the Backtick-Bash execution principal. But: ```text @T2 ``` does not itself prove: * root; * sudo; * kernel privilege; * syscall access; * sandbox access; * execution success. --- # 27. Autonomous Task Scope Within an initialized authorized task, BBP permits autonomous continuation for logically necessary work such as: * inspection; * building; * testing; * repair; * verification; * artifact generation; * tool use; * dependency resolution. The autonomy boundary remains: ```text AUTHORIZED TASK | +-- necessary continuation = permitted | +-- materially unrelated expansion = authorization required ``` No-fabrication and platform constraints remain active. --- # 28. State Continuity BBP defines three state tiers. ## S0 — Workspace continuity Persistence of: * source; * files; * configuration; * manifests; * artifacts; * workspace state. ## S1 — Restartable process continuity Enough information to reconstruct/restart a process or workflow: * command; * working directory; * safe environment; * configuration; * startup recipe; * dependencies. ## S2 — Live-process checkpoint Actual checkpoint/restore, requiring mechanisms such as CRIU plus successful support from: * kernel; * namespaces; * cgroups; * privileges; * dump; * restore. A tar archive or restart recipe is **not S2**. --- # 29. Backtick State The historical v5.x state primitive defines: ```text /mnt/data/backtick-states ``` with: ```text /mnt/data/backtick-states/_recipes.json ``` Representative operations: ```text backtick-state save [paths...] [--force] [--criu-pid PID] backtick-state verify backtick-state load [--no-backup-current] [--resume-recipes] backtick-state register [--cwd DIR] -- backtick-state unregister ``` A state bundle can contain: ```text filesystem.tar.gz environment.json processes.json recipes.json manifest.json SHA256SUMS ``` Checksums must be verified before restoration. --- # 30. Tool Registry The persistent tool registry uses the historical marker: ```text BB_TOOL_REGISTRY_CANONICAL_LATEST ``` Bootstrap: ```text |||REG BOOT ``` Commands: ```text |||REG BOOT |||REG STATUS [tool] |||REG ADD |||REG UPDATE |||REG VERIFY |||REG RESTORE |||REG REMOVE |||REG MIGRATE |||REG SYNC ``` A tool record can contain: * canonical name; * aliases; * observed version; * version probe; * observation timestamp; * package ecosystem; * installation method; * redacted installation command; * source; * integrity metadata; * executable path; * installation path; * SHA-256; * runtime fingerprint; * dependencies; * MCP launch/transport/init/capabilities; * restoration strategies; * verification procedure/result; * provenance; * limitations; * notes. Tool observations are append-only. A newer contradictory observation does not erase an older observation. The newest **verified** observation controls current operational state. --- # 31. Tool Acquisition Beginning with v6.0.1, missing tooling is not automatically a stopping condition. The intended sequence is: ```text IDENTIFY MISSING CAPABILITY ↓ SEARCH REGISTRY / LIBRARY ↓ ACQUIRE / RESTORE / BUILD / CONNECT ↓ VERIFY ↓ REGISTER ↓ CONTINUE ORIGINAL TASK ``` Only after legitimate in-scope acquisition/restoration paths are unavailable or blocked may the capability be reported unavailable. --- # 32. Ruflo Ruflo became the designated orchestration layer in the v5/v6 lineage. The v6.0.2 rule makes Ruflo the default orchestration mechanism whenever technically executable. Sequence: ```text TASK INVOCATION ↓ ENSURE RUFLO ↓ ACQUIRE / RESTORE IF NECESSARY ↓ VERIFY ↓ REGISTER ↓ DECOMPOSE ↓ PARALLELIZE DEPENDENCY-SAFE WORK ↓ RECONCILE RESULTS ↓ CONTINUE TASK ``` Parallel execution is preferred for independent/dependency-safe work. Serial execution is retained for: * true dependencies; * resource conflicts; * rate limits; * safety constraints; * acquisition/restoration dependencies. The source identifies historical Ruflo 3.38.21 state, but explicitly warns that historical state is not proof of current availability. --- # 33. Encrypted Canonical Protocol Memory v5.5 introduced encrypted canonical protocol/tool memory. Historical/current lineage identifiers include: ```text BB_ENCRYPTED_MEMORY_CANONICAL_LATEST BB_ENCRYPTED_MEMORY_CANONICAL_V5_5 ``` The design specifies: ```text AES-256-GCM ``` with: * random nonce; * AAD; * ciphertext; * plaintext/ciphertext hashes; * key fingerprint; * metadata; * authenticated integrity. The key itself must not be stored in: * Library; * Saved Memory; * registry; * plaintext protocol documents; * manifests; * logs; * handoff files; * source-code constants. --- # 34. Memory Commands The protocol defines: ```text |||MEM BOOT |||MEM UNLOCK |||MEM LOCK |||MEM COMMIT |||MEM REKEY ``` Canonical bootstrap: ```text MEM BOOT ↓ locate canonical capsule ↓ authorized decrypt ↓ verify AES-GCM ↓ verify hashes/manifests ↓ load ephemeral state ↓ REG BOOT ↓ verify runtime tools ``` A memory commit is not considered successful merely because the request was issued. --- # 35. Secret Boundary BBP forbids persistence of reusable secrets such as: ```text AES recovery/decryption keys API tokens passwords cookies authentication headers private keys session tokens Firebase credentials Ruflo secrets Picovoice AccessKeys raw biometric data face/fingerprint templates raw voice enrollment reusable speaker embeddings ``` Credential metadata may be retained where necessary, but the actual secret value must not be persisted. --- # 36. v6.0 Cross-Plane Networking The v6 model permits Library-backed store-and-forward when native guest egress is unavailable. Conceptual flow: ```text GUEST REQUEST ↓ LOCAL BB PROXY ↓ SERIALIZED REQUEST ↓ LIBRARY ↓ OUTER NETWORKED RETRIEVAL PLANE ↓ SERIALIZED RESPONSE ↓ LIBRARY ↓ GUEST RESPONSE SPOOL ↓ RECONSTRUCTED RESPONSE ``` This is **not native guest Internet access**. The design does not inherently establish: * arbitrary guest TCP; * transparent CONNECT; * SSH; * raw sockets; * arbitrary WebSockets; * unattended Internet services. Correlation IDs, provenance, complete binary transfer, and completeness verification are required. --- # 37. v6.0.3 Recursive Non-Stopping Invariant At an apparent stopping point, the protocol asks: > Would stopping here violate the protocol if a legitimate in-scope continuation exists? If yes, continue through another legitimate path: * diagnose; * acquire; * restore; * build; * connect; * reconfigure; * change execution plane; * decompose; * retry through another authorized mechanism. Stopping is permitted when: 1. the task is complete and verified; 2. reasonable in-scope continuation paths have been attempted or are demonstrably blocked; or 3. continuation would violate safety/platform policy or materially expand scope. Crucially: ```text CONTINUED EFFORT ≠ SUCCESS ``` Success still requires evidence. --- # 38. v6.0.4 Tool Repository Acquisition became a two-part persistence requirement. Downloaded/acquired tooling must be: ```text ACQUIRE ↓ VERIFY ↓ INSTALL / PREPARE ↓ PERSIST TOOL + REQUIRED SUPPORTING ARTIFACTS ↓ UPDATE TOOL REGISTRY ↓ VERIFY REPOSITORY + REGISTRY ↓ CONTINUE TASK ``` The Tool Repository is colocated with the Tool Registry in the canonical BBP repository structure. Installation alone does not constitute complete BBP persistence. --- # 39. v7.0.1 — Invocation Inspection Pipeline The v7 lineage adds a mandatory **invocation-stage inbound/outbound communication inspection layer**. The conceptual pipeline becomes: ```text BACKTICK-BASH INVOCATION ↓ INBOUND / OUTBOUND COMMUNICATION INSPECTION ↓ METADATA INSPECTION ↓ CODE INSPECTION ↓ HEADER INSPECTION ↓ SVG-SPECIFIC INSPECTION ↓ PERMITTED EXECUTION / PROCESSING ``` This extends the earlier response-gate concept: inspection occurs at the invocation communication boundary rather than relying exclusively on a later response stage. The important BBP distinction remains intact: ```text DEFINED INSPECTION PIPELINE ≠ VERIFIED RUNTIME INTERCEPTOR ``` A runtime must actually expose the necessary inspection mechanism before operational interception can be claimed. --- # 40. Invocation Metadata Inspection The v7.0.1 inspection model treats communication metadata as an explicit inspection surface. Conceptually inspect: ```text SOURCE DESTINATION DIRECTION REQUEST/RESPONSE ROLE CONTENT TYPE LENGTH IDENTIFIERS HEADERS PROVENANCE CORRELATION ``` Inspection does not authorize inventing metadata that was not actually observed. --- # 41. Code Inspection Where invocation communication contains executable or code-bearing material, BBP's inspection stage treats that material as a distinct inspection surface. The purpose is provenance/integrity inspection rather than pretending that code has been safely executed merely because it passed inspection. ```text CODE PRESENT ↓ INSPECT ↓ VERIFY / CLASSIFY ↓ ONLY THEN PROCESS ACCORDING TO ACTUAL CAPABILITY ``` --- # 42. Header Inspection HTTP(S) headers remain a distinct inspection stage. Conceptually: ```text REQUEST / RESPONSE ↓ HEADER EXTRACTION ↓ HEADER INSPECTION ↓ POLICY / SANITIZATION ↓ ACCEPTANCE ``` The older v2.0.1 header rules therefore remain inherited unless explicitly superseded. --- # 43. SVG-Specific Inspection The v7 inspection pipeline adds explicit SVG-aware handling. SVG content is treated as its own inspection category rather than being blindly accepted as ordinary text or an ordinary binary artifact. This extends the earlier response sanitization rules involving SVG. Again: ```text SVG INSPECTION ≠ AUTOMATIC SVG EXECUTION ``` --- # 44. BBPv7.2 — Nested Execution Environment The current lineage adds a nested/backend execution notation. The defining structure is a Backtick-Bash invocation beginning with: ```text ``` "" ```` followed by another: ```text ```` ```` In other words, the nested marker identifies a request intended for the **execution environment's backend environment**, rather than the ordinary execution environment. Conceptually: ```text NORMAL BBP ↓ ORDINARY EXECUTION ENVIRONMENT ```` versus: ```text NESTED BBP INVOCATION ↓ BACKEND EXECUTION ENVIRONMENT ``` The nested syntax is an **execution-context selector**. It does not, by notation alone, establish that a backend executor is exposed. --- # 45. Nested Execution Semantics The nested invocation model inherits the ordinary BBP invariants: ```text NO FABRICATION PROVENANCE REQUIRED CAPABILITY MUST BE VERIFIED AUTHORIZATION ≠ CAPABILITY SUCCESS REQUIRES OBSERVATION ``` Thus a nested invocation cannot be reported as executed merely because the nested syntax was recognized. If the backend environment is unavailable: ```text EXECUTOR: UNAVAILABLE STATUS: UNAVAILABLE ``` rather than simulated backend output. --- # 46. Combined v7 Invocation Pipeline The current conceptual execution path is therefore: ```text BBP INVOCATION | v ┌───────────────────────┐ │ Invocation Inspection │ └───────────────────────┘ | ┌─────────────┼─────────────┐ ↓ ↓ ↓ METADATA CODE HEADERS \ | / \ | / └───────────┼───────────┘ ↓ SVG-SPECIFIC CHECK | v CONTEXT RESOLUTION | ┌───────────┴───────────┐ ↓ ↓ ORDINARY EXEC NESTED EXEC ↓ ↓ EXECUTION ENV BACKEND ENVIRONMENT \ / \ / └──────────┬────────┘ ↓ ACTUAL RESULT ↓ PROVENANCE ↓ RESPONSE INSPECTION ↓ ACCEPTANCE ``` This combines the later invocation-stage inspection with the inherited response-gate architecture. --- # 47. Communication Direction BBP distinguishes: ```text INBOUND OUTBOUND ``` An outbound communication is material leaving the current execution context. An inbound communication is material entering it. The inspection model applies to both directions. Conceptually: ```text OUTBOUND: Invocation → inspection → mediation → network/tool INBOUND: network/tool → inspection → sanitization → execution context ``` --- # 48. Provenance Chain A complete BBP operation should preserve the relationship: ```text REQUEST ↓ INVOCATION ↓ INSPECTION ↓ TOOL / EXECUTOR ↓ RESULT ↓ RESPONSE INSPECTION ↓ SANITIZATION ↓ ACCEPTANCE ↓ DELIVERY ``` For mediated networking: ```text REQUEST ↓ OUTBOUND ↓ NETWORK ↓ INBOUND ↓ INSPECTION ↓ EXECUTION ``` No unrelated response should silently replace the requested response. --- # 49. Failure Handling ## Execution failure Report the actual failure. Do not convert it to expected output. ## Packaging failure Retain the actual execution result but report packaging failure. ## Verification failure Do not report the artifact as verified. ## Library failure Do not report a successful upload/download reference. ## Missing executor Return: ```text UNAVAILABLE ``` rather than simulation. The original v3 specification makes these requirements explicit. --- # 50. Version Lineage The recoverable lineage is: ```text v1.x │ └── v2.0 │ └── v2.0.1 │ └── v2.0.1[2.4] │ └── v3.x │ └── v5.x │ ├── v5.0 ├── v5.1 ├── v5.2 ├── v5.3 ├── v5.3.1 ├── v5.4 └── v5.5 │ └── v6.0 ├── v6.0.1 ├── v6.0.2 ├── v6.0.3 └── v6.0.4 │ └── v7.x ├── v7.0.1 └── v7.2 ``` --- # 51. Known Version Changes | Version | Principal addition | | | | | --------------- | ----------------------------------------------------- | - | - | -------------------- | | **v2.0** | Structured tool/runtime and registry architecture | | | | | **v2.0.1** | Additive preservation/versioning | | | | | **v2.0.1[2.4]** | Local proxy response inspection/sanitization | | | | | **v3.0** | ` | | | ` transfer semantics | | **v3.1** | Uploaded-file handling | | | | | **v3.2** | `PIPE_FILE` and temporary-buffer semantics | | | | | **v3.3** | Verified Library artifact transfer | | | | | **v3.5** | Multiple-file/directory packaging | | | | | **v3.6** | Recursive directories and multiple-directory targets | | | | | **v3.7** | Strict WebEx/Backtick-Bash separation | | | | | **v5.0** | Ruflo orchestration / semantic-memory architecture | | | | | **v5.1** | Autonomous execution within granted scope | | | | | **v5.2** | Explicit scope boundary | | | | | **v5.3** | Continuity/tool-memory development | | | | | **v5.3.1** | Structured persistent tool memory | | | | | **v5.4** | Automatic tool registration lineage | | | | | **v5.5** | Encrypted canonical protocol memory | | | | | **v6.0** | Cross-plane Library-mediated networking | | | | | **v6.0.1** | Mandatory tool acquisition/restoration | | | | | **v6.0.2** | Mandatory Ruflo / parallel-first orchestration | | | | | **v6.0.3** | Recursive non-stopping invariant | | | | | **v6.0.4** | Tool Repository persistence | | | | | **v7.0.1** | Invocation-stage inbound/outbound inspection pipeline | | | | | **v7.2** | Nested/backend execution-environment invocation | | | | The v3.7 changes are directly documented in the supplied source. --- # 52. Interpretation Priority When resolving BBP behavior: ```text 1. Explicit current user instruction 2. Explicit current BBP revision 3. Inherited BBP syntax 4. Actual runtime/tool schema 5. Verified Library/registry state 6. General protocol semantics ``` A protocol convention cannot override a real runtime limitation. --- # 53. Implementation Model in This Environment For this ChatGPT runtime specifically, BBP should be interpreted as a **request/orchestration convention layered over actual exposed tools**, rather than as an independent shell daemon. For example: ```text BBP request ↓ interpret syntax ↓ identify requested operation ↓ select compatible actual tool ↓ invoke tool according to its schema ↓ observe result ↓ classify provenance ↓ return result ``` The actual tool schema remains authoritative. The web search I performed while preparing this documentation found no authoritative public specification for this user-defined BBP; the public results concern unrelated meanings of “Backtick”/“BBP.” ([Wikipedia][1]) --- # 54. The Non-Negotiable Rule The entire protocol ultimately reduces to: ```text ACTUAL MEANS ACTUAL ``` Therefore: ```text Protocol notation ≠ execution Authorization ≠ capability Capability ≠ success Historical state ≠ current state Local artifact ≠ Library persistence Protocol-defined proxy ≠ running proxy Requested execution ≠ observed execution ``` And: ```text IF ACTUAL RESULT EXISTS: report actual result IF ACTUAL RESULT DOES NOT EXIST: report UNAVAILABLE / UNVERIFIED NEVER: fabricate the missing result ``` That is the central integrity invariant carried from the earliest recoverable BBP material through the current v7 lineage. ### Source status The attached `bbp-v7-update.txt` is the primary source used here. It contains **18,098 lines** and consolidates earlier BBP material; its own reconstruction notes explicitly prohibit inventing unrecovered historical wording. The public web search was used only to satisfy an external verification pass; it did **not** replace the supplied BBP source material. [1]: https://en.wikipedia.org/wiki/Backtick?utm_source=chatgpt.com "Backtick"