toolframe-core 0.6.4__tar.gz → 0.7.0__tar.gz

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/.github/workflows/publish.yml

@@ -86,7 +86,7 @@ jobs:
           repository-url: ${{ inputs.index == 'testpypi' && 'https://test.pypi.org/legacy/' || 'https://upload.pypi.org/legacy/' }}
 
   publish-launcher:
-    needs: [release-tag, validate]
+    needs: [release-tag, validate, publish-core]
     runs-on: ubuntu-24.04
     timeout-minutes: 10
     environment:

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/CHANGELOG.md

@@ -5,6 +5,14 @@ imply that its distributions have been published or every target is qualified.
 
 ## Unreleased
 
+## 0.7.0
+
+- Rename the SQL providers to `toolframe-sql-sqlite` and `toolframe-sql-postgres`,
+  with plugin IDs `sql-sqlite` and `sql-postgres`.
+- Adopt SDK 0.4's `RuntimeContext.sql()`, `SqlClient`, and `toolframe.sql` service
+  contract throughout Core, templates, and plugin documentation. Install the
+  matching SDK 0.4-compatible plugin releases together.
+
 ## 0.6.4
 
 - Refresh the container runtime packages to include Debian

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/Cargo.lock

@@ -1186,7 +1186,7 @@ dependencies = [
 
 [[package]]
 name = "toolframe"
-version = "0.6.4"
+version = "0.7.0"
 dependencies = [
  "anyhow",
  "flate2",

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "toolframe"
-version = "0.6.4"
+version = "0.7.0"
 edition = "2024"
 rust-version = "1.88"
 description = "A local-first runtime for agent-built internal apps"

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: toolframe-core
-Version: 0.6.4
+Version: 0.7.0
 Summary: Persistent control host for isolated Toolframe plugins
 Project-URL: Homepage, https://github.com/toolframe/toolframe-core
 Project-URL: Repository, https://github.com/toolframe/toolframe-core
@@ -19,14 +19,14 @@ Requires-Dist: httpx<1,>=0.28
 Requires-Dist: packaging>=25
 Requires-Dist: pyyaml<7,>=6
 Requires-Dist: tomlkit<1,>=0.13
-Requires-Dist: toolframe-sdk==0.3.0
+Requires-Dist: toolframe-sdk==0.4.0
 Requires-Dist: uvicorn==0.42.0
 Requires-Dist: watchfiles<2,>=1
 Requires-Dist: websockets<17,>=15
 Provides-Extra: postgres
 Requires-Dist: psycopg[binary]<4,>=3.3; extra == 'postgres'
 Provides-Extra: tracing
-Requires-Dist: toolframe-sdk[tracing]==0.3.0; extra == 'tracing'
+Requires-Dist: toolframe-sdk[tracing]==0.4.0; extra == 'tracing'
 Description-Content-Type: text/markdown
 
 # Toolframe core
@@ -38,7 +38,7 @@ Description-Content-Type: text/markdown
 Toolframe is a persistent local control host for replaceable Python plugins.
 Core owns composition, immutable package environments, worker lifecycles,
 management operations and a durable Core journal. SQLite (`data/core.sqlite`) is
-the default; Core 0.6 also supports a dedicated PostgreSQL database through runtime
+the default; Core 0.7 also supports a dedicated PostgreSQL database through runtime
 environment configuration. Dashboard, MCP, llms.txt, business
 storage and Entry Register are independently packaged plugins.
 
@@ -397,8 +397,8 @@ the exit code.
 | --- | --- |
 | `toolframe-core` | Persistent FastAPI/Cordis control host, gateway and thin Rust launcher. |
 | `toolframe-sdk` | Public definitions, worker protocol, services, resources and scoped clients. |
-| `toolframe-storage-sqlite` | Local owner databases, SQL authorization, transactions, receipts and migrations. |
-| `toolframe-storage-postgres` | External plugin stores, provisioning, restricted roles, migrations and database backups. |
+| `toolframe-sql-sqlite` | Local owner databases, SQL authorization, transactions, receipts and migrations. |
+| `toolframe-sql-postgres` | External plugin stores, provisioning, restricted roles, migrations and database backups. |
 | `toolframe-streamlit-dashboard` | Native Streamlit pages, shared navigation and management UI. |
 | `toolframe-fastmcp` | MCP tools and Streamable HTTP transport. |
 | `toolframe-llms-txt` | Index composition and explicitly packaged Markdown assets. |

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/README.md

@@ -7,7 +7,7 @@
 Toolframe is a persistent local control host for replaceable Python plugins.
 Core owns composition, immutable package environments, worker lifecycles,
 management operations and a durable Core journal. SQLite (`data/core.sqlite`) is
-the default; Core 0.6 also supports a dedicated PostgreSQL database through runtime
+the default; Core 0.7 also supports a dedicated PostgreSQL database through runtime
 environment configuration. Dashboard, MCP, llms.txt, business
 storage and Entry Register are independently packaged plugins.
 
@@ -366,8 +366,8 @@ the exit code.
 | --- | --- |
 | `toolframe-core` | Persistent FastAPI/Cordis control host, gateway and thin Rust launcher. |
 | `toolframe-sdk` | Public definitions, worker protocol, services, resources and scoped clients. |
-| `toolframe-storage-sqlite` | Local owner databases, SQL authorization, transactions, receipts and migrations. |
-| `toolframe-storage-postgres` | External plugin stores, provisioning, restricted roles, migrations and database backups. |
+| `toolframe-sql-sqlite` | Local owner databases, SQL authorization, transactions, receipts and migrations. |
+| `toolframe-sql-postgres` | External plugin stores, provisioning, restricted roles, migrations and database backups. |
 | `toolframe-streamlit-dashboard` | Native Streamlit pages, shared navigation and management UI. |
 | `toolframe-fastmcp` | MCP tools and Streamable HTTP transport. |
 | `toolframe-llms-txt` | Index composition and explicitly packaged Markdown assets. |

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/docs/architecture.md

@@ -198,13 +198,13 @@ service. Business implementations remain scope-based.
 
 ## External plugin storage
 
-Core 0.5.3 and SDK 0.3 allow a storage provider to select explicit PostgreSQL
+Core 0.7 and SDK 0.4 allow a storage provider to select explicit PostgreSQL
 migration SQL. Core asks the selected provider whether a plugin store is already
 initialized before generating private keys. If an initialized store's retained
 key is missing, activation requires restoring the key. This works for remote
 stores without relying on a local `data.sqlite` file.
 
-Core defaults to `data/core.sqlite`; Core 0.6 can select a dedicated PostgreSQL
+Core defaults to `data/core.sqlite`; Core 0.7 can select a dedicated PostgreSQL
 journal at bootstrap. Private keys and package artifacts remain in the application
 home. Plugin-storage credentials can be injected as environment variables inherited
 by trusted plugin workers; Core journal credentials are removed from those worker

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/docs/authentication.md

@@ -1,6 +1,6 @@
 # Dashboard access and authorization
 
-Core 0.6.1 / SDK 0.3 use explicit scopes. The Entry Register template installs and
+Core 0.7.0 / SDK 0.4 use explicit scopes. The Entry Register template installs and
 enables `toolframe-auth` and `toolframe-dashboard-auth`. An empty
 `init` remains empty. Updating a binary alone never adds these plugins to an
 existing application's composition.
@@ -35,14 +35,14 @@ dashboard_auth = "dashboard-auth"
 failure_mode = "closed"   # new applications keep protected access closed during outages
 
 [plugins.auth]
-source = "pypi:toolframe-auth==0.2.0"
+source = "pypi:toolframe-auth==0.3.0"
 enabled = true
 [plugins.auth.config]
 session_max_seconds = 604800
 session_idle_seconds = 86400
 
 [plugins.dashboard-auth]
-source = "pypi:toolframe-dashboard-auth==0.1.3"
+source = "pypi:toolframe-dashboard-auth==0.2.0"
 enabled = true
 ```
 
@@ -53,7 +53,7 @@ Choose **Deny protected business access** for confidential applications. The
 **Access by entrance** panel shows effective/configured Dashboard and MCP policies,
 local-control authority and declared public HTTP methods. A declaration may be
 unavailable when its plugin is stopped; it is not a credential-protected endpoint.
-The failure-policy editor requires Core 0.6.1 and Dashboard Auth 0.1.3.
+The failure-policy editor requires Core 0.7.0 and Dashboard Auth 0.2.0.
 
 If a first-password operation commits its record but the
 composition changed concurrently, its response includes the one-time secret,
@@ -100,7 +100,7 @@ admission. Healthy reload/restart retains eligible sessions, not Streamlit memor
 
 ## Failure and recovery
 
-New applications created with Core 0.6.1 write `access.failure_mode="closed"`.
+New applications created with Core 0.7.0 write `access.failure_mode="closed"`.
 Templates receive this value only when they omit it; an explicit template choice
 is preserved. When a protected auth provider or Dashboard Auth integration fails
 or is disabled, closed policy makes protected business access unavailable (HTTP
@@ -143,9 +143,9 @@ secrets never enter management operation history or exported composition.
 All plugins now require `AuthorizationSpec`, explicit method `audience`, method
 scopes for business/system APIs and page scopes. Legacy packages fail validation;
 there is no synthetic whole-plugin permission. Update custom definitions using
-the bundled skill's `references/plugin-api.md` and SDK 0.3. Validate the matching
-provider wheels before applying the reviewed composition together. Auth 0.2.0
-and Dashboard Auth 0.1.3 support the flows described here. Keep the old executable/composition for rollback
+the bundled skill's `references/plugin-api.md` and SDK 0.4. Validate the matching
+provider wheels before applying the reviewed composition together. Auth 0.3.0
+and Dashboard Auth 0.2.0 support the flows described here. Keep the old executable/composition for rollback
 until the new packages validate; ordinary business databases keep their schemas.
 
 An upgraded composition without `[access]` adopts public business access once its
@@ -157,8 +157,8 @@ still apply. Generated `plugins/` business source is never overwritten.
 After compatible storage and presentation providers are installed and Core is running:
 
 ```sh
-toolframe --home APP plugin add pypi:toolframe-auth==0.2.0 --enable
-toolframe --home APP plugin add pypi:toolframe-dashboard-auth==0.1.3 --enable
+toolframe --home APP plugin add pypi:toolframe-auth==0.3.0 --enable
+toolframe --home APP plugin add pypi:toolframe-dashboard-auth==0.2.0 --enable
 ```
 
 The standard binary supplies these wheels. Open **Access passwords** through the

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/docs/mcp-authentication.md

@@ -15,7 +15,7 @@ mode = "protected"
 auth_provider = "mcp-auth"
 
 [plugins.mcp-auth]
-source = "pypi:toolframe-mcp-auth==0.1.0"
+source = "pypi:toolframe-mcp-auth==0.3.0"
 enabled = true
 ```
 

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/docs/object-storage.md

@@ -14,7 +14,7 @@ Selecting another provider does not migrate data.
 ## Local development installation
 
 Build the matching object-storage SDK and Core revision before installing the
-new providers. Existing SDK 0.3.0 releases do not include this development API.
+new providers. Existing SDK 0.4.0 releases do not include this development API.
 For sibling development checkouts, build wheels into one directory:
 
 ```sh

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/docs/offline-maintenance.md

@@ -47,7 +47,7 @@ rather than rely on ordering of stores or environment locks.
 | `application_name` | The composition's display name. |
 | `composition_revision` | SHA256 of the current `toolframe.toml`, matching the lock and the journal's last applied desired revision. |
 | `files` | Array of `{path, role, size, mode, sha256}` for regular files to snapshot. `size` is bytes; `mode` is an integer permission bitmask. `sha256` is the verified digest for required immutable artifacts, otherwise `null`. |
-| `stores` | Array of `{path, owner, provider}`. Core uses `owner: null, provider: "core"`; supported business stores identify their plugin owner and `"storage-sqlite"` provider. |
+| `stores` | Array of `{path, owner, provider}`. Core uses `owner: null, provider: "core"`; supported business stores identify their plugin owner and `"sql-sqlite"` provider. |
 | `retained_keys` | Array of `{path, owner, name}` identifying credential files to retain. `owner` is `null` for the management token and undeclared retained key files. No key contents or key hashes are returned. |
 | `dependency_wheels` | Array of `{environment_id, distribution, version, filename, sha256, path}` for recorded dependency wheels. A local `path` is verified against its locked hash; `path: null` is an explicit dependency rehydration prerequisite. |
 | `environment_locks` | Array of `{candidate_id, purpose, environment_id, sha256, python_version, python_implementation, platform_system, platform_machine, requires_python}`. `purpose` is `"backend"` or `"ui"`; the digest identifies the recorded lock text. Interpreter metadata comes from the source environment's regular `pyvenv.cfg`. `python_version` preserves its known precision: `"3.14"` means the source patch version is unknown, while `"3.14.7"` records a full version. Platform fields describe the local source inspection host. |
@@ -87,7 +87,7 @@ environments without importing Core's private journal layout.
 ## Supported state and refusal cases
 
 Format 1 supports local SQLite Core state, business stores managed by the standard
-`storage-sqlite` provider, and regular files within the application home. It
+`sql-sqlite` provider, and regular files within the application home. It
 validates SQLite integrity and business-store application/owner identities with
 read-only immutable connections. It requires an initialized Core schema version
 1 or 2 and the composition lock recorded by that journal. It never adopts a new

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/docs/postgresql-state.md

@@ -1,9 +1,9 @@
 # PostgreSQL Core state
 
-Core 0.6 can keep its management journal in PostgreSQL instead of `data/core.sqlite`.
+Core 0.7 can keep its management journal in PostgreSQL instead of `data/core.sqlite`.
 The journal contains candidates, selected plugin versions, operation history,
 idempotency keys and recovery metadata. It is independent of the optional
-`storage-postgres` plugin, which owns business and authentication data.
+`sql-postgres` plugin, which owns business and authentication data.
 
 Use one Core process per application, Python 3.14+, and PostgreSQL 16+. SQLite is
 the default and keeps its existing schema history. PostgreSQL uses a **dedicated
@@ -15,7 +15,7 @@ business databases. Do not provision Core tables in a business-provider database
 Install the coordinated Core release with its optional driver:
 
 ```sh
-pip install 'toolframe-core[postgres]==0.6.4'
+pip install 'toolframe-core[postgres]==0.7.0'
 toolframe-core --home ./app init
 ```
 

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/docs/releasing.md

@@ -8,17 +8,17 @@ contains no Python wheels; it resolves Core and selected plugins from PyPI.
 
 ## Coordinated first release
 
-Publish SDK 0.3.0 first. Cordis 0.2.2 must be available before Core. Then publish
-the template packages: storage-sqlite 0.3.1, auth 0.2.0, dashboard-auth 0.1.3,
+Publish SDK 0.4.0 first. Cordis 0.2.2 must be available before Core. Then publish
+the template packages: sql-sqlite 0.3.1, auth 0.2.0, dashboard-auth 0.1.3,
 streamlit-dashboard 0.4.2, fastmcp 0.2.1, llms-txt 0.2.1 and
 demo-entry-register 0.3.1. Each repository owns its own tag, validation and
 `publish.yml`. Core's source-validation pins must point to the coordinated
 commits available under the trusted GitHub owner.
 
-Publish `toolframe-core==0.6.4` and `toolframe==0.6.4` together through Core's
+Publish `toolframe-core==0.7.0` and `toolframe==0.6.4` together through Core's
 workflow after those packages are available. Optional packages can follow:
 object-store-local 0.1.0, object-store-s3 0.1.0, mcp-auth 0.2.0, oidc-auth 0.2.0,
-storage-postgres 0.1.0, jobs 0.1.0, audit 0.1.0, backup 0.1.0 and testkit 0.1.0.
+sql-postgres 0.1.0, jobs 0.1.0, audit 0.1.0, backup 0.1.0 and testkit 0.1.0.
 Backup's operator extra requires Core. Testkit's pytest integration is an extra.
 
 ## Publisher setup

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/docs/sql-storage.md

@@ -1,23 +1,23 @@
 # Multiple SQL storage providers
 
 One application can run SQLite and PostgreSQL storage providers together. Each
-plugin owns one managed store and continues to use the SDK's `context.storage()`
+plugin owns one managed store and continues to use the SDK's `context.sql()`
 client. The Core journal is configured separately; see
 [PostgreSQL Core state](postgresql-state.md).
 
 ## Configure a fresh composition
 
 Install both providers, then choose bindings before enabling store-owning plugins.
-For example, with `storage-sqlite` and `storage-postgres` enabled:
+For example, with `sql-sqlite` and `sql-postgres` enabled:
 
 ```toml
 [bindings]
-"toolframe.storage.sql" = "storage-postgres"
-"entry-register/storage" = "storage-sqlite"
+"toolframe.sql" = "sql-postgres"
+"entry-register/sql" = "sql-sqlite"
 ```
 
 The service binding selects PostgreSQL by default. The `plugin-id/alias` binding
-overrides it for Entry Register's `storage` requirement. Auth and other consumers
+overrides it for Entry Register's `sql` requirement. Auth and other consumers
 without overrides use PostgreSQL. Provision every PostgreSQL owner and inject its
 runtime credentials before starting the host, following that provider's setup
 guide. SQLite needs no external server. Both providers use SQL service version 1.
@@ -45,18 +45,18 @@ Keep the SQLite service default and override only new PostgreSQL store owners:
 
 ```toml
 [bindings]
-"toolframe.storage.sql" = "storage-sqlite"
-"orders/storage" = "storage-postgres"
+"toolframe.sql" = "sql-sqlite"
+"orders/sql" = "sql-postgres"
 ```
 
-Here `orders` is an example new plugin ID and `storage` is its SQL requirement
+Here `orders` is an example new plugin ID and `sql` is its SQL requirement
 alias. Use the names declared by the plugin you are installing.
 
 1. Back up the application home and its existing stores. Add the bindings while
    the original SQLite provider remains enabled.
 2. Provision the new PostgreSQL owner, supply its runtime environment, and install
    and enable the PostgreSQL provider before enabling that owner.
-3. Review `plan` and confirm that existing owners retain `storage-sqlite`. Apply
+3. Review `plan` and confirm that existing owners retain `sql-sqlite`. Apply
    the reviewed composition, then verify the new plugin through its public service.
 
 The existing SQLite data stays in its original stores. If PostgreSQL should later
@@ -94,7 +94,7 @@ replacement operations. See the [architecture contract](architecture.md#data-own
 
 ## Plugin and lifecycle limits
 
-A managed store must declare a required `toolframe.storage.sql` dependency. All
+A managed store must declare a required `toolframe.sql` dependency. All
 SQL aliases in one plugin must resolve to the same provider. SQL consumers must
 target a storage provider. Plugins needing another owner's data call its service.
 

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/docs/testing.md

@@ -29,8 +29,8 @@ provider wheels, so it can run from a worktree without sibling source checkouts.
 Use a prepared Core development environment and matching wheels:
 
 ```sh
-TOOLFRAME_SDK_WHEEL=/path/to/toolframe_sdk-0.3.0-py3-none-any.whl \
-TOOLFRAME_STORAGE_SQLITE_WHEEL=/path/to/toolframe_storage_sqlite-0.3.1-py3-none-any.whl \
+TOOLFRAME_SDK_WHEEL=/path/to/toolframe_sdk-0.4.0-py3-none-any.whl \
+TOOLFRAME_STORAGE_SQLITE_WHEEL=/path/to/toolframe_sql_sqlite-0.4.0-py3-none-any.whl \
 .venv/bin/python -m pytest -q \
   tests/test_maintenance.py::test_real_core_sqlite_business_shutdown_has_public_inventory
 ```

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "toolframe-core"
-version = "0.6.4"
+version = "0.7.0"
 description = "Persistent control host for isolated Toolframe plugins"
 readme = "README.md"
 license = "Apache-2.0 AND MIT"
@@ -16,7 +16,7 @@ license-files = [
 authors = [{ name = "byfb", email = "62798989+byfb@users.noreply.github.com" }]
 requires-python = ">=3.14"
 dependencies = [
-  "toolframe-sdk==0.3.0", "fastapi-cordis==0.2.2", "fastapi==0.135.2",
+  "toolframe-sdk==0.4.0", "fastapi-cordis==0.2.2", "fastapi==0.135.2",
   "uvicorn==0.42.0", "httpx>=0.28,<1", "websockets>=15,<17",
   "tomlkit>=0.13,<1", "packaging>=25", "watchfiles>=1,<2", "pyyaml>=6,<7",
 ]
@@ -29,7 +29,7 @@ Issues = "https://github.com/toolframe/toolframe-core/issues"
 
 [project.optional-dependencies]
 postgres = ["psycopg[binary]>=3.3,<4"]
-tracing = ["toolframe-sdk[tracing]==0.3.0"]
+tracing = ["toolframe-sdk[tracing]==0.4.0"]
 
 [project.scripts]
 toolframe-core = "toolframe_core.cli:main"

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/scripts/ci/check-postgres.py

@@ -13,7 +13,7 @@ def main():
         )
     if importlib.util.find_spec("psycopg") is None:
         raise SystemExit("Install the Core postgres extra before running this check")
-    if importlib.util.find_spec("toolframe_storage_postgres") is None:
+    if importlib.util.find_spec("toolframe_sql_postgres") is None:
         raise SystemExit(
             "Install the pinned PostgreSQL storage provider before running this check"
         )

toolframe_core-0.7.0/scripts/ci/dependencies.json

@@ -0,0 +1,14 @@
+{
+  "toolframe-sdk": "2cd153ec36c585a9adb5ad566effc2985d9e222d",
+  "fastapi-cordis": "a132b777a53ee44e4fd02d81b9a2aa9275ca13c0",
+  "toolframe-sql-sqlite": "a2764f83840fb8ad71d7eaf138c7e09799ce19bd",
+  "toolframe-sql-postgres": "e09f6b468572b980855334786e6b0eed72cf8af6",
+  "toolframe-streamlit-dashboard": "f3eff56c436b398bf81fe0bb77b06fa5790fb123",
+  "toolframe-fastmcp": "c8286f7cf7cdcf3522466a8df13945cf55fb58b3",
+  "toolframe-llms-txt": "d52dd2ed54dd4ee23bb1687d43ec347f459f7b5c",
+  "toolframe-demo-entry-register": "638e2163bd1f50f3715e05b418ac9095b4003513",
+  "toolframe-auth": "f43c623cafb1483f3387935d7ef2690ca52088c9",
+  "toolframe-dashboard-auth": "8175ab2c09979d69f63f17a81a1e28d46c2fb466",
+  "toolframe-mcp-auth": "37b53ac0b37637c953cf5e40e59b5dcde8ab2c4b",
+  "toolframe-oidc-auth": "5d88289871c7e961216536ddde812510e319a7fe"
+}

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/scripts/ci/validate.py

@@ -330,7 +330,7 @@ def postgres_checks(root, core, output, env):
         "--no-sources",
         "--find-links",
         root / "workspace/toolframe-sdk/dist",
-        root / "workspace/toolframe-storage-postgres",
+        root / "workspace/toolframe-sql-postgres",
         cwd=core,
         env=env,
     )

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/scripts/dev-wheelhouse.sh

@@ -3,6 +3,6 @@ set -euo pipefail
 toolframe_workspace="$(cd "$(dirname "$0")/../.." && pwd)"
 toolframe_wheels="$toolframe_workspace/toolframe-core/wheelhouse"
 mkdir -p "$toolframe_wheels"
-for repository in toolframe-sdk fastapi-cordis toolframe-storage-sqlite toolframe-llms-txt toolframe-fastmcp toolframe-streamlit-dashboard toolframe-demo-entry-register toolframe-auth toolframe-dashboard-auth toolframe-mcp-auth toolframe-oidc-auth toolframe-core; do
+for repository in toolframe-sdk fastapi-cordis toolframe-sql-sqlite toolframe-llms-txt toolframe-fastmcp toolframe-streamlit-dashboard toolframe-demo-entry-register toolframe-auth toolframe-dashboard-auth toolframe-mcp-auth toolframe-oidc-auth toolframe-core; do
   uv build --no-sources --wheel --out-dir "$toolframe_wheels" "$toolframe_workspace/$repository"
 done

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/scripts/verify-dependencies.py

@@ -124,7 +124,7 @@ def main():
             for edge in graph["edges"]
         )
         assert any(
-            edge["source"] == "entry-register" and edge["target"] == "storage-sqlite"
+            edge["source"] == "entry-register" and edge["target"] == "sql-sqlite"
             for edge in graph["edges"]
         )
         assert {
@@ -144,7 +144,7 @@ def main():
         )
 
         for name, action in (
-            ("storage-sqlite", "reload"),
+            ("sql-sqlite", "reload"),
             ("entry-register", "disable"),
         ):
             plan = operation("plan", {"id": name, "action": action})

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/scripts/verify-release.py

@@ -279,8 +279,8 @@ def main():
                                 != by_id(status)["entry-register"]
                             )
                             assert (
-                                by_id(after)["storage-sqlite"]
-                                == by_id(status)["storage-sqlite"]
+                                by_id(after)["sql-sqlite"]
+                                == by_id(status)["sql-sqlite"]
                             )
                             outcome["reload"] = op
                             outcome["after_reload"] = {

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/scripts/verify-scaffold.py

@@ -40,7 +40,7 @@ def main():
 
     def run(*arguments, expected=0, structured=True):
         completed = subprocess.run(
-            [str(binary), *map(str, arguments)],
+            [str(binary), "--wheelhouse", str(wheels), *map(str, arguments)],
             env=environment,
             cwd=root,
             stdin=subprocess.DEVNULL,
@@ -194,7 +194,7 @@ def main():
     assert inventory(source) == before
     local_wheels = root / "wheelhouse"
     local_wheels.mkdir()
-    for name in ("toolframe_sdk", "toolframe_storage_sqlite"):
+    for name in ("toolframe_core", "toolframe_sdk", "toolframe_sql_sqlite"):
         for wheel in wheels.glob(f"{name}-*.whl"):
             shutil.copy2(wheel, local_wheels / wheel.name)
     configuration = home / "toolframe.toml"
@@ -237,7 +237,7 @@ def main():
                 after["plugins"] == [] and after["operations"] == status["operations"]
             )
             assert configuration.read_bytes() == composition_before
-            storage = next(local_wheels.glob("toolframe_storage_sqlite-*.whl"))
+            storage = next(local_wheels.glob("toolframe_sql_sqlite-*.whl"))
             run("--home", home, "plugin", "add", storage, "--enable", "--json")
             added = run("--home", home, "plugin", "add", plugin_wheel, "--json")
             assert added["status"] == "succeeded"

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/src/main.rs

@@ -23,10 +23,10 @@ fn tracing_requested(value: Option<&str>) -> Result<bool> {
 
 fn core_requirement(postgres: bool, tracing: bool) -> &'static str {
     match (postgres, tracing) {
-        (true, true) => "toolframe-core[postgres,tracing]==0.6.4",
-        (true, false) => "toolframe-core[postgres]==0.6.4",
-        (false, true) => "toolframe-core[tracing]==0.6.4",
-        (false, false) => "toolframe-core==0.6.4",
+        (true, true) => "toolframe-core[postgres,tracing]==0.7.0",
+        (true, false) => "toolframe-core[postgres]==0.7.0",
+        (false, true) => "toolframe-core[tracing]==0.7.0",
+        (false, false) => "toolframe-core==0.7.0",
     }
 }
 
@@ -270,18 +270,18 @@ mod tests {
 
     #[test]
     fn runtime_profiles_select_only_the_requested_extras() {
-        assert_eq!(core_requirement(false, false), "toolframe-core==0.6.4");
+        assert_eq!(core_requirement(false, false), "toolframe-core==0.7.0");
         assert_eq!(
             core_requirement(false, true),
-            "toolframe-core[tracing]==0.6.4"
+            "toolframe-core[tracing]==0.7.0"
         );
         assert_eq!(
             core_requirement(true, false),
-            "toolframe-core[postgres]==0.6.4"
+            "toolframe-core[postgres]==0.7.0"
         );
         assert_eq!(
             core_requirement(true, true),
-            "toolframe-core[postgres,tracing]==0.6.4"
+            "toolframe-core[postgres,tracing]==0.7.0"
         );
     }
 }

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/src/toolframe_core/__init__.py

@@ -1,3 +1,3 @@
 """Toolframe's provider-independent control host."""
 
-__version__ = "0.6.4"
+__version__ = "0.7.0"

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/src/toolframe_core/bundled_skills/toolframe-plugin-design/SKILL.md

@@ -7,7 +7,7 @@ description: Load when designing, creating, or extending a Toolframe business pl
 # Toolframe plugin design
 
 Turn the user's business outcome into an independently packaged Toolframe plugin.
-This skill targets Toolframe Core 0.6.1 and SDK 0.3. The attached references and
+This skill targets Toolframe Core 0.7.0 and SDK 0.4. The attached references and
 starter travel with the application; a Toolframe source checkout is optional.
 
 ## Establish the design

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/src/toolframe_core/bundled_skills/toolframe-plugin-design/assets/sample-plugin/pyproject.toml

@@ -9,7 +9,7 @@ description = "Small independently packaged Toolframe notes plugin"
 license = "MIT"
 license-files = ["LICENSE"]
 requires-python = ">=3.14"
-dependencies = ["toolframe-sdk==0.3.0"]
+dependencies = ["toolframe-sdk==0.4.0"]
 
 [project.optional-dependencies]
 ui = ["streamlit==1.61.0"]

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/src/toolframe_core/bundled_skills/toolframe-plugin-design/assets/sample-plugin/src/toolframe_sample_notes/plugin.py

@@ -52,7 +52,7 @@ plugin = PluginDefinition(
             "sample-notes.write": ScopeSpec(title="Capture notes"),
         }
     ),
-    requires={"storage": Requirement(service="toolframe.storage.sql")},
+    requires={"sql": Requirement(service="toolframe.sql")},
     services={
         SERVICE: ServiceSpec(
             methods={

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/src/toolframe_core/bundled_skills/toolframe-plugin-design/assets/sample-plugin/src/toolframe_sample_notes/service.py

@@ -12,7 +12,7 @@ class Notes(Plugin):
                 "note_invalid", "A note needs 1–1000 nonblank characters."
             )
         body = body.strip()
-        async with self.context.storage().transaction() as tx:
+        async with self.context.sql().transaction() as tx:
             created = await tx.execute(
                 "INSERT INTO notes(body, created_at) VALUES (?, ?)",
                 (body, datetime.now(UTC).isoformat()),
@@ -30,7 +30,7 @@ class Notes(Plugin):
             or not 1 <= limit <= 100
         ):
             raise PluginError("note_invalid", "limit must be an integer from 1 to 100.")
-        notes = await self.context.storage().query(
+        notes = await self.context.sql().query(
             "SELECT id, body, created_at FROM notes ORDER BY id DESC LIMIT ?", (limit,)
         )
         return {"notes": notes, "count": len(notes)}
@@ -44,5 +44,5 @@ class Notes(Plugin):
         raise PluginError("method_not_found", f"Unknown method {service}/{method}")
 
     async def health(self):
-        await self.context.storage().query("SELECT id FROM notes LIMIT 1")
+        await self.context.sql().query("SELECT id FROM notes LIMIT 1")
         return {"runtime": "ready", "business": "ready"}

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/src/toolframe_core/bundled_skills/toolframe-plugin-design/references/operations.md

@@ -51,7 +51,7 @@ Run `serve` in a separate terminal. Add required providers to the composition
 before enabling a plugin that consumes their services. For a local SQLite wheel:
 
 ```sh
-toolframe --home APP plugin add /path/to/toolframe_storage_sqlite-0.3.1-py3-none-any.whl --enable
+toolframe --home APP plugin add /path/to/toolframe_sql_sqlite-0.4.0-py3-none-any.whl --enable
 toolframe --home APP plugin add APP/plugins/customer-notes
 toolframe --home APP plugin validate customer-notes
 toolframe --home APP plugin validate customer-notes --runtime

{toolframe_core-0.6.4 → toolframe_core-0.7.0}/src/toolframe_core/bundled_skills/toolframe-plugin-design/references/plugin-api.md

@@ -1,6 +1,6 @@
 # Public plugin contract
 
-Target: `toolframe-sdk==0.3.0`, Core 0.6.1, Python 3.14. Use this packaged reference
+Target: `toolframe-sdk==0.4.0`, Core 0.7.0, Python 3.14. Use this packaged reference
 and the starter when the source workspace is unavailable. If the installed SDK
 version differs, inspect its public definitions before adapting these examples.
 
@@ -99,7 +99,7 @@ passwords and management tokens are not MCP keys. Protected MCP stays unavailabl
 if its verifier is absent or fails, independently of Dashboard fallback. New Core
 applications write `failure_mode="closed"`; older files omitting it retain legacy
 public fallback. Review existing choices before changing them. The access-password
-page shows entrance states; its failure-policy editor requires Core 0.6.1.
+page shows entrance states; its failure-policy editor requires Core 0.7.0.
 
 Scopes authorize methods, not individual rows. Password labels identify grants,
 not people. Per-person or tenant data needs a trusted identity and explicit
@@ -116,14 +116,14 @@ trusted application code, not a sandbox for untrusted extensions.
 
 ## Managed SQLite
 
-Declare `requires={"storage": Requirement(service="toolframe.storage.sql")}`
+Declare `requires={"sql": Requirement(service="toolframe.sql")}`
 and `store=StoreSchema(revision="v1", migrations=(Migration(...),))` when needed.
 The provider allocates a database for the stable plugin ID. It retains data when
 a plugin is disabled, removed or reloaded. Core's own SQLite holds management
 state and is not business storage.
 
 ```python
-storage = self.context.storage()  # requires alias "storage"
+storage = self.context.sql()  # requires alias "sql"
 async with storage.transaction() as tx:
     result = await tx.execute("INSERT INTO notes(body) VALUES (?)", (body,))
     rows = await tx.query(