feat: versioning scheme — lockstep crates + four independent surfaces

Establish how versions are assigned, bumped, and checked across the
five things that actually change for users: the product itself, the
Rhai SDK, the HTTP API, the database schema, and the inter-service
wire (reserved for cluster mode). Crates ship in lockstep — drift
between picloud-shared and picloud-manager-core is fiction since
they always release together — but surfaces are versioned and
checked at their natural boundaries.

  * docs/versioning.md is the authoritative reference: what gets a
    version, the per-surface compatibility rules, how each surface
    bump cascades to the product version (loose pre-1.0, strict
    post-1.0), and the five enforcement mechanisms (lockstep at
    compile time, /version at runtime, golden SDK contract tests,
    migration replay, CI guardrail).

  * shared::version exposes four constants — PRODUCT_VERSION (from
    CARGO_PKG_VERSION), SDK_VERSION ("1.0"), API_VERSION (1),
    WIRE_VERSION (1). Scripts read SDK_VERSION as ctx.sdk_version
    and can feature-detect against it.

  * Workspace inheritance: `[workspace.package] version = "0.2.0"`
    is the single point of truth; every crate uses
    `version.workspace = true`. dashboard/package.json mirrors.

  * Routes move to /api/v1/* — both control plane
    (/api/v1/admin/*) and data plane (/api/v1/execute/{id}).
    Picloud composes them via a single `/api/v{API_VERSION}` nest,
    so the next major is a copy-paste-and-bump. Caddyfile (dev and
    prod) routes /api/v1/* to picloud and 404s any other /api/*
    so old clients fail loudly instead of getting the SPA shell.
    Dashboard client + integration tests updated.

  * /healthz remains a plain "ok" string (k8s probes); /version is
    the new JSON endpoint returning every surface version in one
    place — product, sdk, api, schema (from
    manager-core::migrations::latest_version), wire.

  * Reasonable bump rationale: API path changes are breaking by
    definition, so 0.1.0 → 0.2.0 (pre-1.0 license to bump minor on
    any breaking change). SDK starts at 1.0 because scripts depend
    on it more strictly than the product depends on its internals;
    we'd rather promise SDK stability early than pull the rug.

Verified live:
  * /healthz → "ok" (plain text)
  * /version → {product:"0.2.0",sdk:"1.0",api:1,schema:1,wire:1}
  * /api/v1/admin/scripts → 200
  * /api/admin/scripts → 404 with error JSON (sunset major)
  * Script can read ctx.sdk_version → "1.0"
  * All 14 integration tests pass against new paths
  * 11 executor-core unit tests pass (added one for sdk_version
    exposure with the major.minor format invariant)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

crates/executor-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "picloud-executor-core"
-version = "0.1.0"
+version.workspace = true
 edition.workspace = true
 rust-version.workspace = true
 license.workspace = true

crates/executor-core/src/engine.rs

@@ -3,7 +3,7 @@ use std::sync::{Arc, Mutex};
 use std::time::Instant;
 
 use chrono::Utc;
-use picloud_shared::{ScriptValidator, ValidationError};
+use picloud_shared::{ScriptValidator, ValidationError, SDK_VERSION};
 use rhai::{Dynamic, Engine as RhaiEngine, EvalAltResult, Map, Module, Scope};
 use serde_json::Value as Json;
 
@@ -172,6 +172,7 @@ fn push_log(logs: &Arc<Mutex<Vec<LogEntry>>>, level: LogLevel, message: &str, da
 
 fn build_ctx_map(req: &ExecRequest) -> Map {
     let mut ctx = Map::new();
+    ctx.insert("sdk_version".into(), SDK_VERSION.into());
     ctx.insert("execution_id".into(), req.execution_id.to_string().into());
     ctx.insert("script_id".into(), req.script_id.to_string().into());
     ctx.insert("script_name".into(), req.script_name.clone().into());

crates/executor-core/tests/engine.rs

@@ -143,6 +143,20 @@ fn module_import_is_blocked() {
     assert!(matches!(err, ExecError::Runtime(_) | ExecError::Parse(_)));
 }
 
+#[test]
+fn ctx_exposes_sdk_version() {
+    let resp = engine()
+        .execute("ctx.sdk_version", req(json!(null)))
+        .unwrap();
+    // Whatever it is, it must look like "MAJOR.MINOR" — that's the
+    // contract scripts feature-detect against.
+    let v = resp.body.as_str().expect("sdk_version is a string");
+    let parts: Vec<&str> = v.split('.').collect();
+    assert_eq!(parts.len(), 2, "expected major.minor, got {v:?}");
+    assert!(parts[0].parse::<u32>().is_ok(), "major not numeric: {v:?}");
+    assert!(parts[1].parse::<u32>().is_ok(), "minor not numeric: {v:?}");
+}
+
 #[test]
 fn body_passes_through_nested_json_round_trip() {
     let src = "#{ statusCode: 200, body: ctx.request.body }";