Questions?
Keep asking.

language / README.md / Model-neutral runtime identity

ShipMBLang owns ShipMB's identity, orchestration role, and declared device-family
context at runtime. Compilation, execution, MCP, and `printurf` remain usable
without a language model. Optional chat providers receive the same ShipMB system
context, so model weights do not define what ShipMB is or what it may claim to do.

No provider is selected by default. To opt into a local OpenAI-compatible
endpoint such as Ollama, configure `SHIPMB_MODEL_PROVIDER=openai_compatible`,
`SHIPMB_MODEL_BASE_URL`, and `SHIPMB_MODEL_NAME`. The legacy Drip adapter is
available only through explicit `SHIPMB_MODEL_PROVIDER=drip` configuration.

The guiding statement is:

```text
If the user can explain the program end to end in natural language syntax shipmb should be able to understand and convert that into machine code to run the programs.
```

For v0.1, the concrete machine target is ShipMBLang bytecode executed by the
local runtime. Native CPU code can come later.

compiler / README.md / What distinguishes ShipMB's approach

ShipMB keeps the user's supported English prose as the maintained program and
combines direct compilation with source-bound clarification, contextual memory,
and explicit guarded execution. These are architectural features, not a claim
that ShipMB is the first or only language to provide them.

- **Direct compilation:** English -> typed syntax and resolved names -> final
  ShipMB bytecode. No Core source, generated Python/JavaScript, TAC, or separate
  intermediate instruction list is produced by this path. The syntax tree is
  still an internal representation; `target_code` contains the final VM artifact,
  not native CPU code or another source-language compilation step.
- **Clarification tied to source:** focused API answers identify a question and
  source revision. Stale answers cannot silently apply to changed prose; the
  revised program is validated before bytecode is emitted.
- **Meaning remembered in context:** confirmed interpretations are reused only
  after compatibility and project/binding checks. Similar wording is a suggestion,
  not confirmation. Memory does not autonomously rewrite grammar or train models.
- **Ability checked at execution:** guarded actions check current ability through
  an injected checker, skip with a reason when unable, and continue independent
  actions. This is verified with simulated outcomes in the Roku profile; it is
  not a claim of completed general device control.
- **Explicit outcomes:** supported meaning compiles; ambiguity requests
  clarification; unsupported meaning gets an explanation. There is no silent
  fallback to a different compilation pipeline.

The current frontend recognizes a defined English grammar, not arbitrary prose.
Broader understanding requires reviewed grammar changes and regression tests.
Remembering meaning never grants execution permission or proves current device
availability. General app, messaging, camera and cross-device integrations remain
planned work. The intended distinction is how these features work together;
historical uniqueness has not been established.

language / README.md / Open-Source Offline/Online Default

ShipMBLang is deterministic and runs locally with no API keys. Training/export tools write local artifacts by default; Hugging Face publishing is optional and never required for compilation, bytecode output, or local runtime use. See OPEN-SOURCE-OFFLINE.md.


ShipMBLang is the natural language programming layer for ShipMB. It lets users
write a program as ordinary instructions in a code editor, then compile those
instructions into a runnable bytecode form.

compiler / README.md / Test ShipMBLang in VS Code (Windows)

You need Python 3.11 or newer, VS Code 1.92 or newer, access to both private
repositories, and the ShipMBLang VSIX extension. ShipMBLangCore is not required
for this direct/general workflow. The extension is currently installed manually.

1. Clone both repositories into the same parent directory (or use your existing
   current checkouts):

   ```powershell
   git clone https://github.com/qramarq/shipmblang.git
   git clone https://github.com/qramarq/shipmblang-compiler.git
   cd shipmblang
   ```

2. In VS Code, use **File > Open Folder** to open the `shipmblang` checkout and
   trust your workspace. Open **Terminal > New Terminal** with PowerShell.
   Confirm `python --version` is 3.11 or newer, then install both packages into
   the same environment:

   ```powershell
   python -m venv .venv
   & .venv/Scripts/python.exe -m pip install -e ../shipmblang-compiler/shipmbcompiler
   & .venv/Scripts/python.exe -m pip install -e .
   ```

   These commands assume sibling clones with the names above. Adjust paths for
   existing checkouts. Environment activation is not required.

3. Obtain `shipmblang-0.3.0.vsix` from the project maintainer, or build it from
   the language checkout with Node.js 22+ and npm installed:

   ```powershell
   cd extensions/vscode-shipmblang
   npx --yes @vscode/vsce package --no-dependencies --out shipmblang-0.3.0.vsix
   cd ../..
   ```

   Press **Ctrl+Shift+P**, select **Extensions: Install from VSIX**, select that
   file, and reload VS Code if prompted. The generated VSIX is not committed to
   the repository or published to the Marketplace.

4. Press **Ctrl+Shift+P** and choose **Preferences: Open Workspace Settings
   (JSON)**. Merge these entries into the existing settings object, replacing
   `C:/path/to/shipmblang` with your actual language checkout path:

   ```json
   {
     "shipmblang.pythonPath": "C:/path/to/shipmblang/.venv/Scripts/python.exe",
     "shipmblang.projectRoot": "C:/path/to/shipmblang",
     "shipmblang.pipeline": "direct",
     "shipmblang.profile": "general",
     "shipmblang.memory": false
   }
   ```

   Use a full executable path, not a command with arguments. An old
   `shipmblang.projectRoot` setting can load an outdated source checkout even
   when the Python environment is correct. Override it here with the current
   checkout; remove obsolete user-level settings when no longer needed.

5. Press **Ctrl+Shift+E** to open Explorer on the left. Expand `examples` and
   open `general_functions.shipmb`. With no text selected, press
   **Ctrl+Shift+P** and run **ShipMBLang: Run Natural Program**. Open
   **View > Output** and select **ShipMBLang** in the dropdown. Expect `720`.
   **ShipMBLang: Compile Natural Program** shows compiler output without running.
   If text is selected, only the selection is submitted.

6. To test diagnostics, create `test.smb` containing `Show missing.` and run
   **ShipMBLang: Compile Natural Program**. Press **Ctrl+Shift+M** to see the
   undefined-name diagnostic in Problems.

For a terminal check from the language checkout:

```powershell
& .venv/Scripts/python.exe -X utf8 -m shipmblang run --file examples/general_functions.shipmb --pipeline direct --profile general --memory off
```

The terminal returns JSON whose `runtime.stdout` is `720\n`. If you see
`No module named shipmblang`, check the selected interpreter and installation.
If options such as `--pipeline` or `--memory` are unrecognized, check for an old
`projectRoot` override. If commands are unavailable, check workspace trust and
that the extension is enabled.

Current VS Code support includes compile/run commands, basic syntax highlighting,
and Problems diagnostics. Autocomplete, rename, debugging, and a language server
are not implemented. General programs must use the implemented grammar; arbitrary
English is not guaranteed to compile. Other IDEs can invoke the installed CLI.

language / README.md / Optional direct English compiler

On Python 3.11 or newer, install the separately named compiler distribution with
`python -m pip install "shipmblang[direct]"`. Both distributions can coexist;
the basic language package still has no required dependencies.

```bash
python -m shipmblang compile "Use the tv pack library in shipmblang to control this Roku TV like a remote." --pipeline direct --memory off
python -m shipmblang compile "Use the tv pack library in shipmblang to control this Roku TV like a remote." --pipeline direct --format json --memory off
python -m shipmblang compile "Use the tv pack library in shipmblang to control this Roku TV like a remote." --pipeline ir --memory off
```

`legacy` remains the default and uses the existing language compiler. `direct`
delegates English interpretation and bytecode generation to shipmbcompiler;
`ir` explicitly selects that compiler's older IR pipeline. There is no automatic
fallback. Direct/IR output defaults to compiler bytecode; JSON includes diagnostics
and clarification questions. Core output is available through `legacy`. A direct
result needing clarification or reporting unsupported behavior exits unsuccessfully
and prints its full explanation, even when bytecode output was requested.

Answer a clarification by keeping the original source and supplying explicit
English with `--interpretation`:

```bash
python -m shipmblang compile "Control it like a remote." --pipeline direct --interpretation "Use the tv pack library in shipmblang to control this Roku TV like a remote." --format json --memory off
```

The compiler validates that interpretation before generating bytecode. It does
not silently substitute a guessed meaning. With memory enabled, confirmed meaning
can be recorded by the compiler. This flag is supported only by the direct pipeline.

Python callers can use `shipmblang.compile_direct_program(...)`. Its result keeps
the compiler schema, including `status`, `clarifications`, and `target_code`.
It accepts explicit bindings, clarification answers and an optional model-provider
callback; no model is selected automatically. Compiler bytecode is not passed to
the legacy language runtime. `run --pipeline direct` uses the compiler's validated
artifact runner. Its Roku profile is an event sandbox, not a live-device controller.

The opt-in `general` profile requires a profile-capable `shipmbcompiler>=0.2.1,<0.3`
build. It compiles supported pure computation into version 0.3 compiler bytecode.
For example, [general_sum.shipmb](examples/general_sum.shipmb) adds the values above
10 in the list 3, 12, 15 and captures `27` followed by a newline:

```bash
python -m shipmblang run --file examples/general_sum.shipmb --pipeline direct --profile general --memory off
```

The JSON result contains `runtime.stdout` and `runtime.output`. Python callers use
`compile_direct_program(source, profile="general", memory=False)` to compile.
The [function example](examples/general_functions.shipmb) uses a typed recursive
factorial function and produces `720`:

```bash
python -m shipmblang run --file examples/general_functions.shipmb --pipeline direct --profile general --memory off
```

`--profile` is only valid with `--pipeline direct`; the default direct profile
remains `roku`, and existing legacy/IR defaults are unchanged. General artifacts
run through the compiler's version-aware loader, not the legacy language runtime.
This initial profile supports its implemented computation subset; it does not
provide arbitrary prose interpretation or live storage, API, UI, or device effects.

Source submissions and outcomes are captured locally when compiler memory is
installed. This includes unsuccessful interpretations and original source text.
`--memory off` or API `memory=False` always disables capture. Otherwise an explicit
`memory_path` or `--memory-path` (also `--memory-db`) enables that database even
when `SHIPMB_MEMORY=off`. Without an explicit path, `SHIPMB_MEMORY=off` disables
capture; `SHIPMB_MEMORY_DB` selects the default database when capture is enabled.
Otherwise the compiler's local user-data location is used. Legacy capture failures, including a missing
optional compiler, warn without discarding the compilation result. Use a disposable
database or disable memory for tests and sensitive inputs.

compiler / README.md / General computation

Compiler 0.2.1 adds an explicit general profile with version 0.3 bytecode:

```powershell
python shipmbc.py examples/general_sum.smb --pipeline direct --profile general --memory off --run
python shipmbc.py examples/general_functions.smb --pipeline direct --profile general --memory off --run
```

The examples return `27` and `720`. This profile performs pure computation and captures
output without live adapters. A weather lookup was used as a temporary integration
experiment and is not part of the shipped language or build requirements.

General syntax currently supports typed integer/boolean/text values, homogeneous
lists, immutable bindings, explicit mutable variables, arithmetic/comparisons,
scoped `If`/`Otherwise`, `For each` and `While`, typed functions with recursion,
and captured `Show` output. Function signatures resolve before calls; ordinary
variables initialize in source order. Parameters are immutable and calls have
separate local scopes, without closures. Every function path must return its
declared type. A maximum of 64 call frames includes the root program.
End blocks explicitly with `End the condition` or `End the loop`. Arithmetic
grouping must be explicit when multiple operators could be interpreted differently.
The VM validates bytecode before execution and bounds steps, integers, collections,
stack size and output. Compilation stays independent of Core, IR and runtime imports.

Modules, richer data, persistence, async and UI remain roadmap work.

For focused API clarification, submit `clarification_answers={"source_revision":
result["source_revision"], "answers": {question_id: "English replacement"}}`.
Answers apply only to the identified source revision and question span. The result
retains original source, revised English and replacement provenance, and validates
the whole revised program before emitting bytecode. Whole-program `interpretation`
answers remain supported. Confirmed memories and parse caches are profile-isolated.

compiler / README.md / Direct English compiler trial

The opt-in direct pipeline compiles English into a syntax tree, resolves symbols,
and emits versioned bytecode without generating Core text or TAC/IR:

```powershell
python shipmbc.py examples/roku_tv.smb --pipeline direct
python shipmbc.py examples/roku_tv.smb --pipeline direct --memory off --run
python scripts/check_roku_prose.py --pipeline direct --strict
python -m unittest discover
```

The compiler distribution is `shipmbcompiler` (Python 3.11+); its import name and
`shipmbc` command are unchanged. The separate `shipmblang` distribution provides
`shipmblang compile --pipeline direct|legacy|ir`. Existing defaults remain `ir`
here and `legacy` in the language package during the trial.

Direct results are `compiled`, `needs_clarification`, or `unsupported`. Unresolved
requests emit no bytecode and never switch pipelines automatically. Supply a
complete English restatement with `--interpretation`, or use `--interactive`
in a terminal. The API is `compile_direct_program(source, ...)`.

Memory is on by default at `%LOCALAPPDATA%/ShipMB/memory.sqlite3`. Override with
`SHIPMB_MEMORY_DB` or `--memory-db`; use `--memory off` for disposable work.
Submissions, failures, clarification history, and confirmed meanings persist.
Only validated confirmations in matching project/binding context are reusable;
similar phrases remain suggestions. See [shared memory](docs/brain/memory.md)
for search, confirmation, export/import, backup, and cache commands.

Ability conditions are enforced by versioned guarded actions. Runtime callers
inject a fresh ability checker; an absent checker skips guarded actions with
an explanation. `--run` remains a simulation: it does not control or install
anything on a real TV. A remembered result never establishes current ability.

The default direct Roku profile covers a bounded TV-pack domain, not arbitrary English.
The separate general profile is described below. The
regression suite includes 40 original requests, 40 independently authored
paraphrases, and 42 adversarial cases. The paraphrases were subsequently used
to improve the parser, so a new unseen corpus is still needed for generalization
measurement. Seven simulated ability scenarios run against all 40 original
requests. Optional model assistance is API-only, disabled by default, and can
propose English interpretations only; user confirmation is required.

Before changing the default, collect at least 20 independently written real-use
examples over a release cycle and resolve incorrect interpretations. Core removal
remains a separate decision after that trial.

language / README.md / Natural Programming Syntax

ShipMBLang now recognizes natural descriptions of the programming structure
used by major languages. A `.shipmb` file can read like an English design paper
while still listing libraries, variables, functions, classes, methods, control
flow, and output.

Supported language targets include Python, JavaScript, TypeScript, Java, C#,
C++, C, Go, Rust, Ruby, PHP, Swift, Kotlin, Scala, R, SQL, and shell scripts.
Common aliases such as `js`, `ts`, `golang`, `c sharp`, and `c plus plus` are
accepted.

Example:

```text
Use Python. Import math. Declare an integer variable total set to 0.
Define a function add_item that takes price and returns total plus price.
Create a class Cart with property items and method add_item that takes item and returns items.
For each item in items then call add_item with item. Show program.
```

Expected Core:

```shiplang
use shipmb
target language "python"
import "math"
let total: int = 0
fn add_item(price) -> total plus price:
  pass
class Cart:
property Cart.items
method Cart.add_item(item) -> items:
  pass
for item in items:
  call add_item with item
program |> show
```

The runtime stores these declarations in the program model and can return them
with `run --format json`. Native process execution remains opt-in future work;
v0.1 records and exposes the compiled bytecode safely. Selecting a target such
as Python or Rust updates the program model; it does not yet emit native source
or switch away from the ShipMBLang bytecode backend.

language / README.md / printurf

`printurf()` is ShipMBLang's codebase-aware debugging primitive. It accepts raw
errors, diagnostics, stack traces, source context, or project files, then returns
a structured explanation:

```text
Error: [what failed]. Cause: [why it failed here]. Fix: [what to change].
```

CLI examples:

```bash
python -m shipmblang printurf app.py --error "NameError: name 'total' is not defined"
python -m shipmblang printurf src/ --max-files 40
python -m shipmblang printurf src/ --error "TypeError: unsupported operand type(s)" --format json
```

language / README.md / Optional direct English compiler

On Python 3.11 or newer, install the separately named compiler distribution with
`python -m pip install "shipmblang[direct]"`. Both distributions can coexist;
the basic language package still has no required dependencies.

```bash
python -m shipmblang compile "Use the tv pack library in shipmblang to control this Roku TV like a remote." --pipeline direct --memory off
python -m shipmblang compile "Use the tv pack library in shipmblang to control this Roku TV like a remote." --pipeline direct --format json --memory off
python -m shipmblang compile "Use the tv pack library in shipmblang to control this Roku TV like a remote." --pipeline ir --memory off
```

`legacy` remains the default and uses the existing language compiler. `direct`
delegates English interpretation and bytecode generation to shipmbcompiler;
`ir` explicitly selects that compiler's older IR pipeline. There is no automatic
fallback. Direct/IR output defaults to compiler bytecode; JSON includes diagnostics
and clarification questions. Core output is available through `legacy`. A direct
result needing clarification or reporting unsupported behavior exits unsuccessfully
and prints its full explanation, even when bytecode output was requested.

Answer a clarification by keeping the original source and supplying explicit
English with `--interpretation`:

```bash
python -m shipmblang compile "Control it like a remote." --pipeline direct --interpretation "Use the tv pack library in shipmblang to control this Roku TV like a remote." --format json --memory off
```

The compiler validates that interpretation before generating bytecode. It does
not silently substitute a guessed meaning. With memory enabled, confirmed meaning
can be recorded by the compiler. This flag is supported only by the direct pipeline.

Python callers can use `shipmblang.compile_direct_program(...)`. Its result keeps
the compiler schema, including `status`, `clarifications`, and `target_code`.
It accepts explicit bindings, clarification answers and an optional model-provider
callback; no model is selected automatically. Compiler bytecode is not passed to
the legacy language runtime. `run --pipeline direct` uses the compiler's validated
artifact runner. Its Roku profile is an event sandbox, not a live-device controller.

The opt-in `general` profile requires a profile-capable `shipmbcompiler>=0.2.1,<0.3`
build. It compiles supported pure computation into version 0.3 compiler bytecode.
For example, [general_sum.shipmb](examples/general_sum.shipmb) adds the values above
10 in the list 3, 12, 15 and captures `27` followed by a newline:

```bash
python -m shipmblang run --file examples/general_sum.shipmb --pipeline direct --profile general --memory off
```

The JSON result contains `runtime.stdout` and `runtime.output`. Python callers use
`compile_direct_program(source, profile="general", memory=False)` to compile.
The [function example](examples/general_functions.shipmb) uses a typed recursive
factorial function and produces `720`:

```bash
python -m shipmblang run --file examples/general_functions.shipmb --pipeline direct --profile general --memory off
```

`--profile` is only valid with `--pipeline direct`; the default direct profile
remains `roku`, and existing legacy/IR defaults are unchanged. General artifacts
run through the compiler's version-aware loader, not the legacy language runtime.
This initial profile supports its implemented computation subset; it does not
provide arbitrary prose interpretation or live storage, API, UI, or device effects.

Source submissions and outcomes are captured locally when compiler memory is
installed. This includes unsuccessful interpretations and original source text.
`--memory off` or API `memory=False` always disables capture. Otherwise an explicit
`memory_path` or `--memory-path` (also `--memory-db`) enables that database even
when `SHIPMB_MEMORY=off`. Without an explicit path, `SHIPMB_MEMORY=off` disables
capture; `SHIPMB_MEMORY_DB` selects the default database when capture is enabled.
Otherwise the compiler's local user-data location is used. Legacy capture failures, including a missing
optional compiler, warn without discarding the compilation result. Use a disposable
database or disable memory for tests and sensitive inputs.

language / README.md / Model-neutral runtime identity

ShipMBLang owns ShipMB's identity, orchestration role, and declared device-family
context at runtime. Compilation, execution, MCP, and `printurf` remain usable
without a language model. Optional chat providers receive the same ShipMB system
context, so model weights do not define what ShipMB is or what it may claim to do.

No provider is selected by default. To opt into a local OpenAI-compatible
endpoint such as Ollama, configure `SHIPMB_MODEL_PROVIDER=openai_compatible`,
`SHIPMB_MODEL_BASE_URL`, and `SHIPMB_MODEL_NAME`. The legacy Drip adapter is
available only through explicit `SHIPMB_MODEL_PROVIDER=drip` configuration.

The guiding statement is:

```text
If the user can explain the program end to end in natural language syntax shipmb should be able to understand and convert that into machine code to run the programs.
```

For v0.1, the concrete machine target is ShipMBLang bytecode executed by the
local runtime. Native CPU code can come later.

compiler / README.md / What distinguishes ShipMB's approach

ShipMB keeps the user's supported English prose as the maintained program and
combines direct compilation with source-bound clarification, contextual memory,
and explicit guarded execution. These are architectural features, not a claim
that ShipMB is the first or only language to provide them.

- **Direct compilation:** English -> typed syntax and resolved names -> final
  ShipMB bytecode. No Core source, generated Python/JavaScript, TAC, or separate
  intermediate instruction list is produced by this path. The syntax tree is
  still an internal representation; `target_code` contains the final VM artifact,
  not native CPU code or another source-language compilation step.
- **Clarification tied to source:** focused API answers identify a question and
  source revision. Stale answers cannot silently apply to changed prose; the
  revised program is validated before bytecode is emitted.
- **Meaning remembered in context:** confirmed interpretations are reused only
  after compatibility and project/binding checks. Similar wording is a suggestion,
  not confirmation. Memory does not autonomously rewrite grammar or train models.
- **Ability checked at execution:** guarded actions check current ability through
  an injected checker, skip with a reason when unable, and continue independent
  actions. This is verified with simulated outcomes in the Roku profile; it is
  not a claim of completed general device control.
- **Explicit outcomes:** supported meaning compiles; ambiguity requests
  clarification; unsupported meaning gets an explanation. There is no silent
  fallback to a different compilation pipeline.

The current frontend recognizes a defined English grammar, not arbitrary prose.
Broader understanding requires reviewed grammar changes and regression tests.
Remembering meaning never grants execution permission or proves current device
availability. General app, messaging, camera and cross-device integrations remain
planned work. The intended distinction is how these features work together;
historical uniqueness has not been established.

language / README.md / How It Works

ShipMBLang's current compiler is deterministic. The public
`shipmblang.natural_syntax` module re-exports the implementation in
`driplm.natural_syntax`, where the compiler:

1. tokenizes natural text with source spans
2. splits it into sentence-level statements
3. collects declarations for the completed compilation-unit symbol table before
   resolving references
4. classifies and lowers statements into semantic operations in source order
5. records symbols for languages, imports, libraries, devices, variables,
   constants, functions, classes, capabilities, installs, and interfaces
6. wraps operations as IR, normalizes/deduplicates them, and inserts missing
   setup such as `use shipmb`, `open_project`, or `on_error`
7. emits `shipmblang-bytecode` with `native_machine_code: false`
8. renders the same bytecode as ShipLang Core for human review

Unknown sentences are not thrown away. They compile to `intent` operations and
show up in both JSON output and Core comments so users can see what the compiler
did not understand yet.

Name resolution is order-insensitive for declarations in the same compilation
unit and scope. The compiler collects declarations first, so a function, method,
class, device, capability, or other declaration may be referenced before its
textual declaration appears. Runtime actions still execute in
emitted/source-defined order unless the compiler explicitly lowers them
otherwise.

Recent updates expanded the first `printurf()` workflow into a broader
program-model compiler: prose can now describe major-language declarations,
domain libraries, device targets, device capabilities, runtime install intent,
client interfaces, and device-family resources.

language / README.md / How It Works

ShipMBLang's current compiler is deterministic. The public
`shipmblang.natural_syntax` module re-exports the implementation in
`driplm.natural_syntax`, where the compiler:

1. tokenizes natural text with source spans
2. splits it into sentence-level statements
3. collects declarations for the completed compilation-unit symbol table before
   resolving references
4. classifies and lowers statements into semantic operations in source order
5. records symbols for languages, imports, libraries, devices, variables,
   constants, functions, classes, capabilities, installs, and interfaces
6. wraps operations as IR, normalizes/deduplicates them, and inserts missing
   setup such as `use shipmb`, `open_project`, or `on_error`
7. emits `shipmblang-bytecode` with `native_machine_code: false`
8. renders the same bytecode as ShipLang Core for human review

Unknown sentences are not thrown away. They compile to `intent` operations and
show up in both JSON output and Core comments so users can see what the compiler
did not understand yet.

Name resolution is order-insensitive for declarations in the same compilation
unit and scope. The compiler collects declarations first, so a function, method,
class, device, capability, or other declaration may be referenced before its
textual declaration appears. Runtime actions still execute in
emitted/source-defined order unless the compiler explicitly lowers them
otherwise.

Recent updates expanded the first `printurf()` workflow into a broader
program-model compiler: prose can now describe major-language declarations,
domain libraries, device targets, device capabilities, runtime install intent,
client interfaces, and device-family resources.

compiler / README.md / General computation

Compiler 0.2.1 adds an explicit general profile with version 0.3 bytecode:

```powershell
python shipmbc.py examples/general_sum.smb --pipeline direct --profile general --memory off --run
python shipmbc.py examples/general_functions.smb --pipeline direct --profile general --memory off --run
```

The examples return `27` and `720`. This profile performs pure computation and captures
output without live adapters. A weather lookup was used as a temporary integration
experiment and is not part of the shipped language or build requirements.

General syntax currently supports typed integer/boolean/text values, homogeneous
lists, immutable bindings, explicit mutable variables, arithmetic/comparisons,
scoped `If`/`Otherwise`, `For each` and `While`, typed functions with recursion,
and captured `Show` output. Function signatures resolve before calls; ordinary
variables initialize in source order. Parameters are immutable and calls have
separate local scopes, without closures. Every function path must return its
declared type. A maximum of 64 call frames includes the root program.
End blocks explicitly with `End the condition` or `End the loop`. Arithmetic
grouping must be explicit when multiple operators could be interpreted differently.
The VM validates bytecode before execution and bounds steps, integers, collections,
stack size and output. Compilation stays independent of Core, IR and runtime imports.

Modules, richer data, persistence, async and UI remain roadmap work.

For focused API clarification, submit `clarification_answers={"source_revision":
result["source_revision"], "answers": {question_id: "English replacement"}}`.
Answers apply only to the identified source revision and question span. The result
retains original source, revised English and replacement provenance, and validates
the whole revised program before emitting bytecode. Whole-program `interpretation`
answers remain supported. Confirmed memories and parse caches are profile-isolated.

compiler / README.md / General computation

Compiler 0.2.1 adds an explicit general profile with version 0.3 bytecode:

```powershell
python shipmbc.py examples/general_sum.smb --pipeline direct --profile general --memory off --run
python shipmbc.py examples/general_functions.smb --pipeline direct --profile general --memory off --run
```

The examples return `27` and `720`. This profile performs pure computation and captures
output without live adapters. A weather lookup was used as a temporary integration
experiment and is not part of the shipped language or build requirements.

General syntax currently supports typed integer/boolean/text values, homogeneous
lists, immutable bindings, explicit mutable variables, arithmetic/comparisons,
scoped `If`/`Otherwise`, `For each` and `While`, typed functions with recursion,
and captured `Show` output. Function signatures resolve before calls; ordinary
variables initialize in source order. Parameters are immutable and calls have
separate local scopes, without closures. Every function path must return its
declared type. A maximum of 64 call frames includes the root program.
End blocks explicitly with `End the condition` or `End the loop`. Arithmetic
grouping must be explicit when multiple operators could be interpreted differently.
The VM validates bytecode before execution and bounds steps, integers, collections,
stack size and output. Compilation stays independent of Core, IR and runtime imports.

Modules, richer data, persistence, async and UI remain roadmap work.

For focused API clarification, submit `clarification_answers={"source_revision":
result["source_revision"], "answers": {question_id: "English replacement"}}`.
Answers apply only to the identified source revision and question span. The result
retains original source, revised English and replacement provenance, and validates
the whole revised program before emitting bytecode. Whole-program `interpretation`
answers remain supported. Confirmed memories and parse caches are profile-isolated.

compiler / README.md / Quoted English paragraphs (compiler 0.2.2)

The direct general profile accepts a whole program wrapped in straight double
quotes or smart double quotes. Paragraph breaks and the original source positions
are preserved. Use straight double quotes for text values inside the program.

```text
“Start with total at 4, then add 8 to total and show total.

Multiply total by 3. Subtract 9 from total and display me total.”
```

Run the checked-in example:

```powershell
python shipmbc.py examples/quoted_paragraph.smb --pipeline direct --profile general --memory off --run
```

Its captured output is `12` followed by `27`. `Start with` declares a mutable
value. `Start with 12. Add 15 and show the result.` produces `27`; an omitted
arithmetic target requires exactly one visible mutable integer. Name the target
when more than one is available. Coordinated commands can use `and`, `then`, or
`and then` before supported action verbs. Text inside string values remains data.

This is a defined grammar, not unrestricted English understanding. Unsupported
clauses and ambiguous references prevent emission of a runnable artifact; they
are not silently omitted. Quotation marks do not enable new device capabilities.
Existing unquoted programs and explicit pipeline choices remain supported.

compiler / README.md / Multiple paragraphs (compiler 0.2.3)

A program can contain blank-line paragraphs without quotes, inside one outer
quoted block, or in separately quoted blocks separated by a blank line. Straight
and smart double-quote wrappers are supported; strings inside use straight quotes.
Paragraphs share the program's bindings and function declarations. A paragraph
break does **not** close a loop, condition, or function: use explicit `End` clauses.

See [the multi-paragraph example](examples/multiple_paragraphs.smb), which totals
measurements above 10 and prints `27`, including a condition and loop spanning
paragraphs:

```powershell
python shipmbc.py examples/multiple_paragraphs.smb --pipeline direct --profile general --memory off --run
```

The entire document is checked before any runnable artifact is returned. An
unknown or ambiguous clause in a later paragraph blocks the whole program.
Source text, Unicode character offsets, and file line endings are retained for
clarifications. Focused answers remain bound to the original source revision.

Regression tests cover shared bindings, cross-paragraph function calls, nested
loops/conditions, LF and CRLF, string contents, later-paragraph errors, and
malformed wrappers. Complexity still means composition of the implemented grammar:
arbitrary narrative, implied block endings, and unsupported operations require
clarification or an implementation rather than a guessed translation.

compiler / README.md / Compile English Prose Without Core Output

Core text is an optional readable export, not an intermediate input required
for prose compilation. Compile the Roku example directly to bytecode:

```powershell
python shipmbc.py examples/roku_tv.smb --emit target_code,diagnostics
```

For the Python API:

```python
from shipmbcompiler import compile_source

result = compile_source(source, include_core=False)
assert result["core_source"] is None
```

This path does not load the Core parser/renderer or the runtime. It requires no
`shipmblangcore` checkout, live TV, model, or network connection. Bytecode and
diagnostics are unchanged by the export option. Existing API defaults still
include Core; CLI `--emit core_source` and `--emit all` request it explicitly.
Explicit Core source input remains supported and loads its parser as needed.
`--run` loads the event-only runtime only after compilation succeeds.

The Roku paragraph records the library, Roku device, remote capabilities,
command error handler, installation request, and voice/chat client interfaces.
It does not prove that a device can install ShipMB or supply those interfaces.
In the compatibility IR pipeline, `if able` is recognized in the syntax tree
but its interface declarations do not enforce that condition. Use the direct
pipeline for runtime guards; the IR path retains its historical behavior.

To test prose understanding, supply alternative English phrasings and the
expected library, device, capabilities, error behavior, and client interfaces.
No device address, credentials, or hardware is needed for compilation tests.
The [40-case English prose corpus](docs/roku-prose-tests.md) records expected
meanings, per-action ability conditions, and a runnable baseline audit.
Current recognition covers a limited deterministic subset, not arbitrary prose.

compiler / README.md / WordNet Trigger Synonyms

ShipMBCompiler has a curated built-in thesaurus for compiler trigger words, and
it can augment that thesaurus from local WordNet database files. The compiler
does not need internet access at compile time; pass a local WordNet `dict`
directory, set `SHIPMB_WORDNET_DIR`, or layer in a local slang/shorthand
thesaurus with `--thesaurus-path`.

```powershell
$env:SHIPMB_WORDNET_DIR = "C:\path\to\WordNet-3.1\dict"
python shipmbc.py source.smb --emit core_source,trigger_lexicon,diagnostics
```

or:

```powershell
python shipmbc.py source.smb --wordnet-dir "C:\path\to\WordNet-3.1\dict" --emit core_source,trigger_lexicon,diagnostics
```

Optional slang/shorthand files can be JSON, CSV, TSV, or simple text:

```json
{
  "triggers": {
    "use": { "synonyms": ["grab"] },
    "execute": { "synonyms": ["kick"] },
    "show": { "synonyms": ["flash"] }
  }
}
```

```powershell
python shipmbc.py source.smb --wordnet-dir "C:\path\to\WordNet\dict" --thesaurus-path ".\shipmb-slang.json" --emit core_source,trigger_lexicon,diagnostics
```

WordNet synonyms expand only known ShipMB compiler triggers. Antonyms are kept
for diagnostics and negation handling, not for silently running the opposite
operation. WordNet glosses are loaded as dictionary definitions for future
disambiguation and `printurf()` explanations.

compiler / README.md / Urban Dictionary Slang Sync

Urban Dictionary support is optional tooling for discovery and curation. Normal
compilation remains offline and reproducible: `compile_source()` never calls the
network or the MCP server. Instead, run a sync step against the sibling
`urbandictmcp` project, review the generated JSON, then pass it back with
`--thesaurus-path`.

```powershell
python shipmbc.py slang sync `
  --terms "fire up,pull up,kill app,send it" `
  --map "fire up=open" `
  --map "kill=close" `
  --map "send it=execute" `
  --out examples/urban-slang-thesaurus.json `
  --urban-mcp-server "C:\Users\admin\Documents\urbandictmcp\server.js"
```

Mapped terms become active synonyms only when the right side is one of the
known ShipMB compiler triggers such as `open`, `close`, or `execute`. Unmapped
terms stay under `urban_dictionary_candidates` with Urban Dictionary provenance,
scores, and definition IDs for review. The generated `triggers` object is still
loaded through the same local thesaurus path as any hand-written JSON:

```powershell
python shipmbc.py examples\roku_tv.smb --thesaurus-path examples\urban-slang-thesaurus.json --emit core_source,diagnostics
```

Crowdsourced definitions can be noisy or offensive, so keep generated files in
review before relying on them in a project. The loader still refuses new
compiler triggers outside the curated canonical trigger table, and blocked
aliases such as `pack -> library` remain blocked to preserve identifier phrases
like `tv pack library`.

compiler / README.md / Language Ports

The Python implementation remains the reference compiler. Standalone C++, Go,
and Rust ports implement the interoperable v0.1 Roku TV-pack prose/Core slice
and emit the same structured `shipmblang-bytecode` contract for the supported
examples.

- [C++ port](cpp/README.md) — CMake/C++17, no third-party dependencies.
- [Go port](go/README.md) — standard-library-only Go CLI.
- [Rust port](rust/README.md) — Cargo crate using `serde_json` for JSON.

All ports are offline and preserve lowercase bytecode opcode names. Their
per-port READMEs include build and run commands.

compiler / README.md / Test ShipMBLang in VS Code (Windows)

You need Python 3.11 or newer, VS Code 1.92 or newer, access to both private
repositories, and the ShipMBLang VSIX extension. ShipMBLangCore is not required
for this direct/general workflow. The extension is currently installed manually.

1. Clone both repositories into the same parent directory (or use your existing
   current checkouts):

   ```powershell
   git clone https://github.com/qramarq/shipmblang.git
   git clone https://github.com/qramarq/shipmblang-compiler.git
   cd shipmblang
   ```

2. In VS Code, use **File > Open Folder** to open the `shipmblang` checkout and
   trust your workspace. Open **Terminal > New Terminal** with PowerShell.
   Confirm `python --version` is 3.11 or newer, then install both packages into
   the same environment:

   ```powershell
   python -m venv .venv
   & .venv/Scripts/python.exe -m pip install -e ../shipmblang-compiler/shipmbcompiler
   & .venv/Scripts/python.exe -m pip install -e .
   ```

   These commands assume sibling clones with the names above. Adjust paths for
   existing checkouts. Environment activation is not required.

3. Obtain `shipmblang-0.3.0.vsix` from the project maintainer, or build it from
   the language checkout with Node.js 22+ and npm installed:

   ```powershell
   cd extensions/vscode-shipmblang
   npx --yes @vscode/vsce package --no-dependencies --out shipmblang-0.3.0.vsix
   cd ../..
   ```

   Press **Ctrl+Shift+P**, select **Extensions: Install from VSIX**, select that
   file, and reload VS Code if prompted. The generated VSIX is not committed to
   the repository or published to the Marketplace.

4. Press **Ctrl+Shift+P** and choose **Preferences: Open Workspace Settings
   (JSON)**. Merge these entries into the existing settings object, replacing
   `C:/path/to/shipmblang` with your actual language checkout path:

   ```json
   {
     "shipmblang.pythonPath": "C:/path/to/shipmblang/.venv/Scripts/python.exe",
     "shipmblang.projectRoot": "C:/path/to/shipmblang",
     "shipmblang.pipeline": "direct",
     "shipmblang.profile": "general",
     "shipmblang.memory": false
   }
   ```

   Use a full executable path, not a command with arguments. An old
   `shipmblang.projectRoot` setting can load an outdated source checkout even
   when the Python environment is correct. Override it here with the current
   checkout; remove obsolete user-level settings when no longer needed.

5. Press **Ctrl+Shift+E** to open Explorer on the left. Expand `examples` and
   open `general_functions.shipmb`. With no text selected, press
   **Ctrl+Shift+P** and run **ShipMBLang: Run Natural Program**. Open
   **View > Output** and select **ShipMBLang** in the dropdown. Expect `720`.
   **ShipMBLang: Compile Natural Program** shows compiler output without running.
   If text is selected, only the selection is submitted.

6. To test diagnostics, create `test.smb` containing `Show missing.` and run
   **ShipMBLang: Compile Natural Program**. Press **Ctrl+Shift+M** to see the
   undefined-name diagnostic in Problems.

For a terminal check from the language checkout:

```powershell
& .venv/Scripts/python.exe -X utf8 -m shipmblang run --file examples/general_functions.shipmb --pipeline direct --profile general --memory off
```

The terminal returns JSON whose `runtime.stdout` is `720\n`. If you see
`No module named shipmblang`, check the selected interpreter and installation.
If options such as `--pipeline` or `--memory` are unrecognized, check for an old
`projectRoot` override. If commands are unavailable, check workspace trust and
that the extension is enabled.

Current VS Code support includes compile/run commands, basic syntax highlighting,
and Problems diagnostics. Autocomplete, rename, debugging, and a language server
are not implemented. General programs must use the implemented grammar; arbitrary
English is not guaranteed to compile. Other IDEs can invoke the installed CLI.

compiler / README.md / Install Locally

From this folder in PowerShell:

```powershell
powershell -ExecutionPolicy Bypass -File scripts/install_dev.ps1
.\.venv\Scripts\Activate.ps1
shipmbc examples\roku_tv.smb --run --emit core_source,runtime,diagnostics
```

This installs the compiler workspace in an isolated `.venv` and exposes local `shipmbc`
wrappers in `.venv\Scripts`. No internet is required; the installer links the
workspace into the venv directly instead of downloading Python packages.

compiler / README.md / What distinguishes ShipMB's approach

ShipMB keeps the user's supported English prose as the maintained program and
combines direct compilation with source-bound clarification, contextual memory,
and explicit guarded execution. These are architectural features, not a claim
that ShipMB is the first or only language to provide them.

- **Direct compilation:** English -> typed syntax and resolved names -> final
  ShipMB bytecode. No Core source, generated Python/JavaScript, TAC, or separate
  intermediate instruction list is produced by this path. The syntax tree is
  still an internal representation; `target_code` contains the final VM artifact,
  not native CPU code or another source-language compilation step.
- **Clarification tied to source:** focused API answers identify a question and
  source revision. Stale answers cannot silently apply to changed prose; the
  revised program is validated before bytecode is emitted.
- **Meaning remembered in context:** confirmed interpretations are reused only
  after compatibility and project/binding checks. Similar wording is a suggestion,
  not confirmation. Memory does not autonomously rewrite grammar or train models.
- **Ability checked at execution:** guarded actions check current ability through
  an injected checker, skip with a reason when unable, and continue independent
  actions. This is verified with simulated outcomes in the Roku profile; it is
  not a claim of completed general device control.
- **Explicit outcomes:** supported meaning compiles; ambiguity requests
  clarification; unsupported meaning gets an explanation. There is no silent
  fallback to a different compilation pipeline.

The current frontend recognizes a defined English grammar, not arbitrary prose.
Broader understanding requires reviewed grammar changes and regression tests.
Remembering meaning never grants execution permission or proves current device
availability. General app, messaging, camera and cross-device integrations remain
planned work. The intended distinction is how these features work together;
historical uniqueness has not been established.

compiler / README.md / Compatibility IR Compiler

The compatibility IR implementation is a narrow v0.1 slice, not the full future
ShipMBLang spec. It supports the Roku TV pack prose path, editable Core source,
offline trigger synonyms, TAC-style IR, conservative optimization, JSON
bytecode, diagnostics, and an optional runtime shim.

The runtime shim is event-only: it never executes a shell command, contacts a
device, installs a package, or invokes MCP. It validates bytecode before
recording any events and skips `--run` when compilation has errors. See
[SECURITY.md](SECURITY.md) for the enforced boundaries and requirements for a
real backend.

The compatibility pipeline is:

```text
source -> lexicon -> lexer -> prose/Core parser -> editable Core -> semantics -> TAC IR -> optimizer -> bytecode -> optional runtime
```

Unsupported prose, unsupported targets, and runtime capability problems are
reported as structured diagnostics plus `printurf` explanations.

language / README.md / Optional direct English compiler

On Python 3.11 or newer, install the separately named compiler distribution with
`python -m pip install "shipmblang[direct]"`. Both distributions can coexist;
the basic language package still has no required dependencies.

```bash
python -m shipmblang compile "Use the tv pack library in shipmblang to control this Roku TV like a remote." --pipeline direct --memory off
python -m shipmblang compile "Use the tv pack library in shipmblang to control this Roku TV like a remote." --pipeline direct --format json --memory off
python -m shipmblang compile "Use the tv pack library in shipmblang to control this Roku TV like a remote." --pipeline ir --memory off
```

`legacy` remains the default and uses the existing language compiler. `direct`
delegates English interpretation and bytecode generation to shipmbcompiler;
`ir` explicitly selects that compiler's older IR pipeline. There is no automatic
fallback. Direct/IR output defaults to compiler bytecode; JSON includes diagnostics
and clarification questions. Core output is available through `legacy`. A direct
result needing clarification or reporting unsupported behavior exits unsuccessfully
and prints its full explanation, even when bytecode output was requested.

Answer a clarification by keeping the original source and supplying explicit
English with `--interpretation`:

```bash
python -m shipmblang compile "Control it like a remote." --pipeline direct --interpretation "Use the tv pack library in shipmblang to control this Roku TV like a remote." --format json --memory off
```

The compiler validates that interpretation before generating bytecode. It does
not silently substitute a guessed meaning. With memory enabled, confirmed meaning
can be recorded by the compiler. This flag is supported only by the direct pipeline.

Python callers can use `shipmblang.compile_direct_program(...)`. Its result keeps
the compiler schema, including `status`, `clarifications`, and `target_code`.
It accepts explicit bindings, clarification answers and an optional model-provider
callback; no model is selected automatically. Compiler bytecode is not passed to
the legacy language runtime. `run --pipeline direct` uses the compiler's validated
artifact runner. Its Roku profile is an event sandbox, not a live-device controller.

The opt-in `general` profile requires a profile-capable `shipmbcompiler>=0.2.1,<0.3`
build. It compiles supported pure computation into version 0.3 compiler bytecode.
For example, [general_sum.shipmb](examples/general_sum.shipmb) adds the values above
10 in the list 3, 12, 15 and captures `27` followed by a newline:

```bash
python -m shipmblang run --file examples/general_sum.shipmb --pipeline direct --profile general --memory off
```

The JSON result contains `runtime.stdout` and `runtime.output`. Python callers use
`compile_direct_program(source, profile="general", memory=False)` to compile.
The [function example](examples/general_functions.shipmb) uses a typed recursive
factorial function and produces `720`:

```bash
python -m shipmblang run --file examples/general_functions.shipmb --pipeline direct --profile general --memory off
```

`--profile` is only valid with `--pipeline direct`; the default direct profile
remains `roku`, and existing legacy/IR defaults are unchanged. General artifacts
run through the compiler's version-aware loader, not the legacy language runtime.
This initial profile supports its implemented computation subset; it does not
provide arbitrary prose interpretation or live storage, API, UI, or device effects.

Source submissions and outcomes are captured locally when compiler memory is
installed. This includes unsuccessful interpretations and original source text.
`--memory off` or API `memory=False` always disables capture. Otherwise an explicit
`memory_path` or `--memory-path` (also `--memory-db`) enables that database even
when `SHIPMB_MEMORY=off`. Without an explicit path, `SHIPMB_MEMORY=off` disables
capture; `SHIPMB_MEMORY_DB` selects the default database when capture is enabled.
Otherwise the compiler's local user-data location is used. Legacy capture failures, including a missing
optional compiler, warn without discarding the compilation result. Use a disposable
database or disable memory for tests and sensitive inputs.

compiler / README.md / General computation

Compiler 0.2.1 adds an explicit general profile with version 0.3 bytecode:

```powershell
python shipmbc.py examples/general_sum.smb --pipeline direct --profile general --memory off --run
python shipmbc.py examples/general_functions.smb --pipeline direct --profile general --memory off --run
```

The examples return `27` and `720`. This profile performs pure computation and captures
output without live adapters. A weather lookup was used as a temporary integration
experiment and is not part of the shipped language or build requirements.

General syntax currently supports typed integer/boolean/text values, homogeneous
lists, immutable bindings, explicit mutable variables, arithmetic/comparisons,
scoped `If`/`Otherwise`, `For each` and `While`, typed functions with recursion,
and captured `Show` output. Function signatures resolve before calls; ordinary
variables initialize in source order. Parameters are immutable and calls have
separate local scopes, without closures. Every function path must return its
declared type. A maximum of 64 call frames includes the root program.
End blocks explicitly with `End the condition` or `End the loop`. Arithmetic
grouping must be explicit when multiple operators could be interpreted differently.
The VM validates bytecode before execution and bounds steps, integers, collections,
stack size and output. Compilation stays independent of Core, IR and runtime imports.

Modules, richer data, persistence, async and UI remain roadmap work.

For focused API clarification, submit `clarification_answers={"source_revision":
result["source_revision"], "answers": {question_id: "English replacement"}}`.
Answers apply only to the identified source revision and question span. The result
retains original source, revised English and replacement provenance, and validates
the whole revised program before emitting bytecode. Whole-program `interpretation`
answers remain supported. Confirmed memories and parse caches are profile-isolated.

compiler / README.md / What distinguishes ShipMB's approach

ShipMB keeps the user's supported English prose as the maintained program and
combines direct compilation with source-bound clarification, contextual memory,
and explicit guarded execution. These are architectural features, not a claim
that ShipMB is the first or only language to provide them.

- **Direct compilation:** English -> typed syntax and resolved names -> final
  ShipMB bytecode. No Core source, generated Python/JavaScript, TAC, or separate
  intermediate instruction list is produced by this path. The syntax tree is
  still an internal representation; `target_code` contains the final VM artifact,
  not native CPU code or another source-language compilation step.
- **Clarification tied to source:** focused API answers identify a question and
  source revision. Stale answers cannot silently apply to changed prose; the
  revised program is validated before bytecode is emitted.
- **Meaning remembered in context:** confirmed interpretations are reused only
  after compatibility and project/binding checks. Similar wording is a suggestion,
  not confirmation. Memory does not autonomously rewrite grammar or train models.
- **Ability checked at execution:** guarded actions check current ability through
  an injected checker, skip with a reason when unable, and continue independent
  actions. This is verified with simulated outcomes in the Roku profile; it is
  not a claim of completed general device control.
- **Explicit outcomes:** supported meaning compiles; ambiguity requests
  clarification; unsupported meaning gets an explanation. There is no silent
  fallback to a different compilation pipeline.

The current frontend recognizes a defined English grammar, not arbitrary prose.
Broader understanding requires reviewed grammar changes and regression tests.
Remembering meaning never grants execution permission or proves current device
availability. General app, messaging, camera and cross-device integrations remain
planned work. The intended distinction is how these features work together;
historical uniqueness has not been established.

compiler / README.md / What distinguishes ShipMB's approach

ShipMB keeps the user's supported English prose as the maintained program and
combines direct compilation with source-bound clarification, contextual memory,
and explicit guarded execution. These are architectural features, not a claim
that ShipMB is the first or only language to provide them.

- **Direct compilation:** English -> typed syntax and resolved names -> final
  ShipMB bytecode. No Core source, generated Python/JavaScript, TAC, or separate
  intermediate instruction list is produced by this path. The syntax tree is
  still an internal representation; `target_code` contains the final VM artifact,
  not native CPU code or another source-language compilation step.
- **Clarification tied to source:** focused API answers identify a question and
  source revision. Stale answers cannot silently apply to changed prose; the
  revised program is validated before bytecode is emitted.
- **Meaning remembered in context:** confirmed interpretations are reused only
  after compatibility and project/binding checks. Similar wording is a suggestion,
  not confirmation. Memory does not autonomously rewrite grammar or train models.
- **Ability checked at execution:** guarded actions check current ability through
  an injected checker, skip with a reason when unable, and continue independent
  actions. This is verified with simulated outcomes in the Roku profile; it is
  not a claim of completed general device control.
- **Explicit outcomes:** supported meaning compiles; ambiguity requests
  clarification; unsupported meaning gets an explanation. There is no silent
  fallback to a different compilation pipeline.

The current frontend recognizes a defined English grammar, not arbitrary prose.
Broader understanding requires reviewed grammar changes and regression tests.
Remembering meaning never grants execution permission or proves current device
availability. General app, messaging, camera and cross-device integrations remain
planned work. The intended distinction is how these features work together;
historical uniqueness has not been established.