fix(security): server-authoritative approval gate + auth/session/file hardening

Remediate the HIGH and security-relevant findings from the 2026-07-11 audit.

H1 — the per-env approval gate is now server-authoritative. The governing
project is resolved from the target node's nearest-claimed ancestor
(`governing_env_policy`/`_tree` + `governing_project_id` +
`ProjectRepository::get_environments_by_id`), independent of the client-supplied
`[project]`. Omitting or spoofing the project block can no longer skip a gate the
owning project established; a to-create group resolves its declared parent's
chain so a fresh subtree node inherits the gate. Fails closed on any read error.

H2 — the API-key prefix slice (`&rest[..8]`) is now the boundary-safe
`rest.get(..8)`, so an attacker-supplied multibyte bearer can't panic the request
task (unauthenticated per-request DoS). Regression test added.

C1 — admin sessions gain an absolute lifetime cap (migration 0070,
`PICLOUD_SESSION_ABSOLUTE_TTL_HOURS`, default 30d): `lookup` filters it, `touch`
clamps the sliding bump to it, so a continuously-used or stolen-but-warm token
self-expires. Mirrors the data-plane app-user cap.

C2 — `Cache-Control: no-store` on the login and API-key-mint responses (the two
that return a raw credential), so a proxy/CDN/browser cache can't retain it.

B8 — file downloads are header-safe: `sanitize_stored_filename` guarantees a
valid `HeaderValue` (no panic on a control-char name) and BOTH the per-app and
group download paths now set attachment + `X-Content-Type-Options: nosniff` +
a restrictive CSP, closing a group-path stored-XSS gap.

Also folds in the server-side plan-warning plumbing (`plan_warnings`,
`PlanResult::warnings`) and the `app_only_reject` message helper that the CLI
plan-preview change builds on, plus operator security notes (reads-open shared-
topic SSE; the `--env` label is advisory, not a boundary).

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

crates/picloud-cli/tests/env_approval.rs

@@ -409,6 +409,77 @@ fn persisted_policy_gates_a_request_that_omits_it() {
     );
 }
 
+#[ignore = "needs DATABASE_URL pointing at a running Postgres"]
+#[test]
+fn omitting_the_project_block_entirely_does_not_bypass_a_persisted_gate() {
+    // Audit 2026-07-11 H1: the earlier gate keyed the persisted policy on the
+    // client-supplied `project.slug`, so a request that OMITTED `[project]`
+    // ENTIRELY (`project: null`, not just empty `environments`) yielded an empty
+    // policy and skipped the gate. The fix resolves the GOVERNING project
+    // server-side from the target node's nearest-claimed ancestor, so a request
+    // to a claimed, gated node can no longer apply just by dropping `[project]`.
+    let Some(fx) = common::fixture_or_skip() else {
+        return;
+    };
+    let env = common::admin_env(fx);
+    let group = common::unique_slug("eao-grp");
+    let project = common::unique_slug("eao-proj");
+    let _g = GroupGuard::new(&env.url, &env.token, &group);
+    common::pic_as(&env)
+        .args(["groups", "create", &group])
+        .assert()
+        .success();
+
+    let http = reqwest::blocking::Client::new();
+
+    // Seed: declare + approve the gate → claims the group AND persists
+    // `production=true` on the owning project.
+    let seed = http
+        .post(format!("{}/api/v1/admin/tree/apply", env.url))
+        .bearer_auth(&env.token)
+        .json(&serde_json::json!({
+            "bundle": { "nodes": [{ "kind": "group", "slug": group, "bundle": {} }] },
+            "project": {
+                "slug": project,
+                "environments": { "production": { "confirm": true } }
+            },
+            "env": "production",
+            "approved_envs": ["production"],
+            "prune": false,
+        }))
+        .send()
+        .expect("seed apply");
+    assert!(
+        seed.status().is_success(),
+        "the seeding apply (declared + approved) must succeed (got {}: {})",
+        seed.status(),
+        seed.text().unwrap_or_default()
+    );
+
+    // Attack: a raw apply that OMITS the `project` block entirely (no `project`
+    // key on the wire) to the same gated node, WITHOUT approving `production`.
+    // The server resolves the governing project from the node itself, so this is
+    // refused (409) — it does NOT quietly apply.
+    let omit = http
+        .post(format!("{}/api/v1/admin/tree/apply", env.url))
+        .bearer_auth(&env.token)
+        .json(&serde_json::json!({
+            "bundle": { "nodes": [{ "kind": "group", "slug": group, "bundle": {} }] },
+            "env": "production",
+            "approved_envs": [],
+            "prune": false,
+        }))
+        .send()
+        .expect("omit apply");
+    assert_eq!(
+        omit.status().as_u16(),
+        409,
+        "omitting [project] must not bypass the persisted gate (got {}: {})",
+        omit.status(),
+        omit.text().unwrap_or_default()
+    );
+}
+
 #[ignore = "needs DATABASE_URL pointing at a running Postgres"]
 #[test]
 fn flipping_a_gate_to_false_in_the_same_request_still_gates() {