@mriekki/project-forge 4.11.2 → 4.13.0

package/assets/generated/deployment/docs/RECOVERY_READINESS.md

@@ -0,0 +1,66 @@
+# Recovery Readiness Contract V1
+
+Project Forge distinguishes a verified database backup from verified application recovery. A successful SQLite backup proves only the database artifact created by the application's SQLite maintenance contract; it does not prove that every dependency required to recover authentication or the full application is available or usable.
+
+## Recovery states
+
+Reusable evidence must keep these concepts separate:
+
+1. `databaseBackupVerified` — the SQLite database backup operation completed successfully.
+2. `verifiedBackupScope` — currently `database` for SQLite backup evidence.
+3. `recoveryScopeDeclared` — the consumer supplied a strict, non-secret recovery declaration.
+4. `unresolvedRequiredDependencies` — required non-database dependencies that still need recovery-time verification.
+5. `authenticationPolicyVerified` — the selected authentication recovery policy has been dynamically verified after restore.
+6. `applicationRecoveryReady` — all required recovery dependencies and the selected policy have been verified for the restored application.
+
+Current SQLite backup/import/migration commands never set `applicationRecoveryReady` to true. Deployment Kit does not yet provide a general restore engine.
+
+## Recovery manifest
+
+`sqlite backup` and existing-database `sqlite migrate` may receive `--recovery-manifest <path>` pointing to UTF-8 JSON with exactly this schema:
+
+```json
+{
+  "schemaVersion": 1,
+  "authenticationPolicy": "invalidate-authentication",
+  "dependencies": [
+    {
+      "id": "data-protection-key-ring",
+      "type": "cryptographic-key-ring",
+      "required": true
+    }
+  ]
+}
+```
+
+`authenticationPolicy` may be `preserve-authentication`, `invalidate-authentication`, or `null`. Dependency IDs/types are non-secret identifiers only. Unknown fields fail closed. Do not put paths, keys, credentials, cookies, tokens, passwords, action links, provider secrets, or secret values in the manifest.
+
+The normalized manifest is fingerprinted deterministically and the privacy-safe declaration/readiness summary is included in SQLite evidence. Secret contents are neither archived nor printed by this contract. First-install migration, import, interrupted-import recovery, and rollback checking do not accept a recovery manifest in V1.
+
+## Authentication recovery policies
+
+`preserve-authentication` means a future recovery workflow must prove that required cryptographic/protector dependencies remain usable and that retaining historical authentication state is acceptable.
+
+`invalidate-authentication` means a future recovery workflow must prove that sessions and action links from historical state cannot authenticate or mutate accounts after recovery. Merely replacing a key ring is not sufficient evidence because password hashes, security stamps, sessions, token expiry/consumption, and similar state may also exist in the restored database.
+
+Neither policy is considered verified by a database backup alone.
+
+## Pre-traffic invariant
+
+A future restore operation must fail closed and keep the restored application unavailable to normal traffic until all required recovery dependencies and the selected authentication policy have been verified. Restore completion and database integrity must never be treated as equivalent to application recovery readiness.
+
+## Requirements
+
+- **PF-REC-001** — Database backup verification must never imply whole-application recovery readiness.
+- **PF-REC-002** — Consumers may declare non-database recovery dependencies without exposing secret values.
+- **PF-REC-003** — Required dependencies must be verified before application recovery readiness can pass.
+- **PF-REC-004** — Authentication-bearing consumers must select an explicit post-restore authentication policy when they want application recovery readiness.
+- **PF-REC-005** — Historical restore must remain unavailable to normal traffic until that policy is verified.
+- **PF-REC-006** — Incomplete or failed recovery evidence fails closed.
+- **PF-REC-007** — Existing SQLite-only consumers retain current database backup behavior and database-only success semantics.
+- **PF-REC-008** — Read-only planning/readiness inspection performs no restore, key manipulation, revocation, rotation, or other destructive action.
+- **PF-REC-009** — Dynamic recovery validation uses disposable fixtures and never logs secret material.
+
+## Non-scope
+
+This contract does not implement generic secret archival, provider-specific secret storage, key transport, key rotation, session/token mutation, or a general database/application restore workflow. Those require separate requirements, plan approval, implementation review, and release/adoption gates.

package/assets/generated/deployment/src/project_forge_deployment/recovery_scope.py

@@ -0,0 +1,116 @@
+"""Reusable recovery-scope declarations and non-secret readiness evidence."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from typing import Any
+
+from .errors import DeploymentKitError
+
+RECOVERY_SCHEMA_VERSION = 1
+AUTHENTICATION_POLICIES = {"preserve-authentication", "invalidate-authentication"}
+_ID_RE = re.compile(r"^[a-z0-9](?:[a-z0-9._-]{0,62}[a-z0-9])?$")
+_ALLOWED_TOP = {"schemaVersion", "authenticationPolicy", "dependencies"}
+_ALLOWED_DEPENDENCY = {"id", "type", "required"}
+
+
+def _identifier(value: Any, field: str) -> str:
+    if not isinstance(value, str) or _ID_RE.fullmatch(value) is None:
+        raise DeploymentKitError(f"{field} must use lowercase letters, digits, dots, underscores, and internal hyphens.")
+    return value
+
+
+def normalize_recovery_scope(value: dict[str, Any] | None) -> dict[str, Any]:
+    """Normalize a strict, non-secret recovery declaration.
+
+    The declaration deliberately has no free-form values, paths, credentials, or
+    provider configuration. It describes recovery dependencies without storing
+    their contents or teaching generic persistence tooling how to archive them.
+    """
+    if value is None:
+        return {
+            "schemaVersion": RECOVERY_SCHEMA_VERSION,
+            "declared": False,
+            "authenticationPolicy": None,
+            "dependencies": [],
+            "manifestSha256": None,
+        }
+    if not isinstance(value, dict) or set(value) != _ALLOWED_TOP:
+        raise DeploymentKitError(
+            "Recovery manifest must contain exactly schemaVersion, authenticationPolicy, and dependencies."
+        )
+    if value["schemaVersion"] != RECOVERY_SCHEMA_VERSION:
+        raise DeploymentKitError(f"Recovery manifest schemaVersion must be {RECOVERY_SCHEMA_VERSION}.")
+    policy = value["authenticationPolicy"]
+    if policy is not None and policy not in AUTHENTICATION_POLICIES:
+        raise DeploymentKitError(
+            "authenticationPolicy must be preserve-authentication, invalidate-authentication, or null."
+        )
+    dependencies = value["dependencies"]
+    if not isinstance(dependencies, list):
+        raise DeploymentKitError("Recovery manifest dependencies must be an array.")
+    normalized: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    for dependency in dependencies:
+        if not isinstance(dependency, dict) or set(dependency) != _ALLOWED_DEPENDENCY:
+            raise DeploymentKitError("Each recovery dependency must contain exactly id, type, and required.")
+        dependency_id = _identifier(dependency["id"], "Recovery dependency id")
+        dependency_type = _identifier(dependency["type"], "Recovery dependency type")
+        required = dependency["required"]
+        if not isinstance(required, bool):
+            raise DeploymentKitError("Recovery dependency required must be a boolean.")
+        if dependency_id in seen:
+            raise DeploymentKitError(f"Duplicate recovery dependency id: {dependency_id}")
+        seen.add(dependency_id)
+        normalized.append({"id": dependency_id, "type": dependency_type, "required": required})
+    normalized.sort(key=lambda item: item["id"])
+    canonical = {
+        "schemaVersion": RECOVERY_SCHEMA_VERSION,
+        "authenticationPolicy": policy,
+        "dependencies": normalized,
+    }
+    fingerprint = hashlib.sha256(
+        json.dumps(canonical, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    ).hexdigest()
+    return {
+        **canonical,
+        "declared": True,
+        "manifestSha256": fingerprint,
+    }
+
+
+def public_recovery_scope(scope: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "schemaVersion": scope["schemaVersion"],
+        "declared": scope["declared"],
+        "authenticationPolicy": scope["authenticationPolicy"],
+        "dependencies": [dict(item) for item in scope["dependencies"]],
+        "manifestSha256": scope["manifestSha256"],
+    }
+
+
+def recovery_readiness(scope: dict[str, Any], *, database_backup_verified: bool) -> dict[str, Any]:
+    unresolved = [item["id"] for item in scope["dependencies"] if item["required"]]
+    return {
+        "schemaVersion": RECOVERY_SCHEMA_VERSION,
+        "databaseBackupVerified": bool(database_backup_verified),
+        "verifiedBackupScope": "database" if database_backup_verified else None,
+        "recoveryScopeDeclared": scope["declared"],
+        "authenticationPolicy": scope["authenticationPolicy"],
+        "authenticationPolicyVerified": False if scope["authenticationPolicy"] is not None else None,
+        "unresolvedRequiredDependencies": unresolved,
+        "manifestSha256": scope["manifestSha256"],
+        "applicationRecoveryReady": False,
+        "readinessReason": "restore-policy-not-verified" if scope["declared"] else "recovery-scope-not-declared",
+    }
+
+
+def recovery_evidence(scope: dict[str, Any], *, database_backup_verified: bool) -> dict[str, Any]:
+    """Return the privacy-safe evidence payload persisted with a SQLite operation."""
+    readiness = recovery_readiness(scope, database_backup_verified=database_backup_verified)
+    return {
+        **readiness,
+        "dependencies": [dict(item) for item in scope["dependencies"]],
+    }

package/assets/generated/deployment/src/project_forge_deployment/sqlite_adapter.py

@@ -14,6 +14,7 @@ from .app_runtime import APP_ROOT
 from .box_platform import platform_status
 from .errors import DeploymentKitError
 from .profiles import load_profile
+from .recovery_scope import normalize_recovery_scope, public_recovery_scope, recovery_evidence, recovery_readiness
 from .sqlite_adapter_remote import REMOTE_SCRIPT
 from .ssh import ssh_args, verify_access
 
@@ -111,6 +112,7 @@ def normalize_sqlite_request(
     maintenance_environment: dict[str, str] | Iterable[tuple[str, str]],
     run_as: str | None = None, database_file: str | None = None,
     source_database: str | None = None, first_install: bool = False,
+    recovery_scope: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     request = {
         "ownerRepo": _owner_repo(owner_repo),
@@ -122,6 +124,7 @@ def normalize_sqlite_request(
         "runAs": _run_as(run_as) if run_as is not None else None,
         "databaseFile": _database_file(database_file) if database_file is not None else None,
         "sourceDatabase": _source_database(source_database) if source_database is not None else None,
+        "recoveryScope": normalize_recovery_scope(recovery_scope),
     }
     if request["sourceDatabase"] is not None:
         if request["runAs"] is None or request["databaseFile"] is None:
@@ -140,6 +143,7 @@ def _b64(value: str) -> str:
 def build_remote_script(spec: dict[str, Any] | None = None) -> str:
     spec = spec or {}
     env = spec.get("maintenanceEnvironment", {})
+    recovery_payload = json.dumps(spec.get("recoveryEvidence", {}), sort_keys=True, separators=(",", ":"))
     replacements = {
         "__APP_ROOT__": APP_ROOT,
         "__SQLITE_SCHEMA_VERSION__": str(SQLITE_SCHEMA_VERSION),
@@ -154,6 +158,7 @@ def build_remote_script(spec: dict[str, Any] | None = None) -> str:
         "__RESERVATION_SHA__": spec.get("reservationSha256", ""),
         "__ENV_KEYS__": " ".join(f"'{_b64(k)}'" for k in env),
         "__ENV_VALUES__": " ".join(f"'{_b64(v)}'" for v in env.values()),
+        "__RECOVERY_EVIDENCE_B64__": _b64(recovery_payload),
     }
     script = REMOTE_SCRIPT
     for placeholder, value in replacements.items():
@@ -291,6 +296,12 @@ def plan_sqlite_operation(
         spec.update(runAs=existing["runAs"], databaseFile=existing["databaseFile"], reservationSha256=existing["reservationSha256"])
         if action in {"backup", "migrate", "rollback-check"} and not existing["databasePresent"]:
             raise DeploymentKitError(f"SQLite {action} requires an existing database.")
+    creates_verified_backup = bool(action == "backup" or (action == "migrate" and not request["firstInstall"]))
+    recovery_scope = request["recoveryScope"]
+    spec["recoveryEvidence"] = recovery_evidence(
+        recovery_scope,
+        database_backup_verified=creates_verified_backup,
+    )
     return {
         "targetName": name, "action": action, "ownerRepo": request["ownerRepo"],
         "environment": request["environment"], "productionClassified": production_classified,
@@ -299,7 +310,10 @@ def plan_sqlite_operation(
         "sourceDatabase": request["sourceDatabase"] if action == "import" else None,
         "firstInstall": bool(request["firstInstall"] if action == "migrate" else False),
         "stopsManagedRuntime": bool(action == "migrate" and existing and existing["managedRuntimeRunning"]),
-        "createsVerifiedBackup": bool(action == "backup" or (action == "migrate" and not request["firstInstall"])),
+        "createsVerifiedBackup": creates_verified_backup,
+        "verifiedBackupScope": "database" if creates_verified_backup else None,
+        "recoveryScope": public_recovery_scope(recovery_scope),
+        "applicationRecoveryReadyAfterOperation": False,
         "inventorySnapshot": _snapshot(inventory), "expectedReservationSha256": expected_sha, "spec": spec,
     }
 
@@ -319,11 +333,18 @@ def authorization_phrase(plan: dict[str, Any]) -> str:
 
 
 def apply_sqlite_operation(plan: dict[str, Any]) -> dict[str, Any]:
-    required = {"targetName", "action", "ownerRepo", "environment", "productionClassified", "appSlug", "image", "databaseFile", "runAs", "sourceDatabase", "firstInstall", "stopsManagedRuntime", "createsVerifiedBackup", "inventorySnapshot", "expectedReservationSha256", "spec"}
+    required = {
+        "targetName", "action", "ownerRepo", "environment", "productionClassified", "appSlug", "image",
+        "databaseFile", "runAs", "sourceDatabase", "firstInstall", "stopsManagedRuntime", "createsVerifiedBackup",
+        "verifiedBackupScope", "recoveryScope", "applicationRecoveryReadyAfterOperation", "inventorySnapshot",
+        "expectedReservationSha256", "spec",
+    }
     if not isinstance(plan, dict) or set(plan) != required or not isinstance(plan["productionClassified"], bool):
         raise DeploymentKitError("Malformed SQLite operation plan.")
     if plan["environment"] == "production" and not plan["productionClassified"]:
         raise DeploymentKitError("Literal production environment must remain Production-classified.")
+    if plan["applicationRecoveryReadyAfterOperation"] is not False:
+        raise DeploymentKitError("SQLite operations cannot claim application recovery readiness.")
     _require_ready_platform(plan["targetName"])
     current = sqlite_inventory(plan["targetName"])
     if _snapshot(current) != plan["inventorySnapshot"]:
@@ -334,6 +355,10 @@ def apply_sqlite_operation(plan: dict[str, Any]) -> dict[str, Any]:
     result["mutated"] = True
     result["operation"] = plan["action"]; result["operationOutput"] = output.strip()
     result["productionClassified"] = plan["productionClassified"]
+    result["recoveryReadiness"] = recovery_readiness(
+        plan["spec"]["recoveryScope"],
+        database_backup_verified=plan["createsVerifiedBackup"],
+    )
     return result
 
 

package/assets/generated/deployment/src/project_forge_deployment/sqlite_adapter_remote.py

@@ -19,6 +19,7 @@ FIRST_INSTALL="__FIRST_INSTALL__"
 RESERVATION_SHA="__RESERVATION_SHA__"
 ENV_KEYS=(__ENV_KEYS__)
 ENV_VALUES=(__ENV_VALUES__)
+RECOVERY_EVIDENCE_B64="__RECOVERY_EVIDENCE_B64__"
 
 b64d() { printf '%s' "$1" | base64 --decode; }
 meta_value() {
@@ -121,6 +122,7 @@ decode_spec() {
     RUN_AS="$(b64d "$RUN_AS_B64")"
     DATABASE_FILE="$(b64d "$DB_FILE_B64")"
     SOURCE_DATABASE="$(b64d "$SOURCE_DB_B64")"
+    RECOVERY_EVIDENCE_JSON="$(b64d "$RECOVERY_EVIDENCE_B64")"
     valid_repo "$OWNER" || { echo "Invalid SQLite owner repository." >&2; exit 45; }
     valid_slug "$ENVIRONMENT" || { echo "Invalid SQLite environment." >&2; exit 45; }
     valid_slug "$APP_SLUG" || { echo "Invalid SQLite app slug." >&2; exit 45; }
@@ -129,6 +131,7 @@ decode_spec() {
     valid_db_file "$DATABASE_FILE" || { echo "Invalid SQLite database file name." >&2; exit 45; }
     [[ "$RESERVATION_SHA" =~ ^[0-9a-f]{64}$ ]] || { echo "Invalid SQLite reservation fingerprint." >&2; exit 45; }
     [[ "${#ENV_KEYS[@]}" -eq "${#ENV_VALUES[@]}" && "${#ENV_KEYS[@]}" -gt 0 ]] || { echo "Invalid SQLite maintenance environment payload." >&2; exit 45; }
+    [[ "$RECOVERY_EVIDENCE_JSON" == \{*\} ]] || { echo "Invalid SQLite recovery evidence payload." >&2; exit 45; }
     local index key
     for index in "${!ENV_KEYS[@]}"; do
         key="$(b64d "${ENV_KEYS[$index]}")"
@@ -210,8 +213,8 @@ run_migrate() {
 record_evidence() {
     local root="$1" action="$2" outcome="$3" artifact="${4:-}" timestamp
     timestamp="$(date -u +'%Y-%m-%dT%H:%M:%SZ')"
-    printf '{"timestamp":"%s","action":"%s","ownerRepo":"%s","environment":"%s","appSlug":"%s","image":"%s","databaseFile":"%s","reservationSha256":"%s","artifact":"%s","outcome":"%s"}\n' \
-        "$timestamp" "$action" "$OWNER" "$ENVIRONMENT" "$APP_SLUG" "$IMAGE" "$DATABASE_FILE" "$RESERVATION_SHA" "$artifact" "$outcome" >> "$root/sqlite-evidence.jsonl"
+    printf '{"timestamp":"%s","action":"%s","ownerRepo":"%s","environment":"%s","appSlug":"%s","image":"%s","databaseFile":"%s","reservationSha256":"%s","artifact":"%s","outcome":"%s","recovery":%s}\n' \
+        "$timestamp" "$action" "$OWNER" "$ENVIRONMENT" "$APP_SLUG" "$IMAGE" "$DATABASE_FILE" "$RESERVATION_SHA" "$artifact" "$outcome" "$RECOVERY_EVIDENCE_JSON" >> "$root/sqlite-evidence.jsonl"
     chmod 0600 "$root/sqlite-evidence.jsonl"
 }
 
@@ -287,7 +290,7 @@ operate() {
             backup_name="backup-$stamp-$DATABASE_FILE"
             run_backup "$DATA" "$BACKUPS" "$backup_name"
             record_evidence "$ROOT" backup backed-up "$backup_name"
-            printf 'SQLite verified backup created: %s\n' "$BACKUPS/$backup_name"
+            printf 'SQLite verified database backup created: %s\n' "$BACKUPS/$backup_name"
             ;;
         migrate)
             if [[ "$FIRST_INSTALL" == true ]]; then
@@ -311,12 +314,12 @@ operate() {
                 if [[ "$MANAGED_RUNNING" == true ]]; then docker stop "$MANAGED_CONTAINER" >/dev/null; fi
                 if ! run_migrate "$DATA"; then
                     record_evidence "$ROOT" migrate failed "$backup_name"
-                    echo "SQLite migration failed; verified pre-migration backup is retained and managed runtime remains stopped." >&2
+                    echo "SQLite migration failed; verified pre-migration database backup is retained and managed runtime remains stopped." >&2
                     exit 50
                 fi
                 run_check "$DATA"
                 record_evidence "$ROOT" migrate migrated "$backup_name"
-                printf 'SQLite migration completed; verified pre-migration backup: %s\n' "$BACKUPS/$backup_name"
+                printf 'SQLite migration completed; verified pre-migration database backup: %s\n' "$BACKUPS/$backup_name"
             fi
             ;;
         rollback-check)
@@ -337,4 +340,4 @@ case "$ACTION" in
     import|backup|migrate|rollback-check) operate ;;
     *) echo "Unsupported SQLite adapter action: $ACTION" >&2; exit 2 ;;
 esac
-'''
+'''

package/assets/generated/deployment/src/project_forge_deployment/sqlite_cli.py

@@ -1,6 +1,7 @@
 """CLI for the SQLite persistence adapter."""
 from __future__ import annotations
 import argparse, json, sys
+from pathlib import Path
 from typing import Any
 from .errors import DeploymentKitError
 from .sqlite_adapter import authorization_phrase, apply_sqlite_operation, normalize_sqlite_request, plan_sqlite_operation, sqlite_inventory
@@ -28,6 +29,18 @@ def _parse_env(items: list[str]) -> list[tuple[str,str]]:
     return out
 
 
+def _load_recovery_manifest(path: str | None) -> dict[str, Any] | None:
+    if path is None:
+        return None
+    try:
+        value = json.loads(Path(path).read_text(encoding='utf-8'))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise DeploymentKitError(f"Could not read recovery manifest as UTF-8 JSON: {error}") from error
+    if not isinstance(value, dict):
+        raise DeploymentKitError("Recovery manifest root must be a JSON object.")
+    return value
+
+
 def _confirm(args: argparse.Namespace, phrase: str, action: str) -> None:
     if args.yes: return
     if input(f"Type {phrase} to {action}: ").strip() != phrase:
@@ -50,6 +63,10 @@ def _common(parser: argparse.ArgumentParser) -> None:
     parser.add_argument('--yes', action='store_true')
 
 
+def _recovery_manifest_arg(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument('--recovery-manifest', help='Optional strict non-secret JSON declaration of recovery dependencies and authentication policy')
+
+
 def _import_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument('--run-as', required=True)
     parser.add_argument('--database-file', required=True)
@@ -62,8 +79,8 @@ def build_parser() -> argparse.ArgumentParser:
     inv=sub.add_parser('inventory',help='Read SQLite persistence reservations without writes'); inv.add_argument('name'); inv.add_argument('--json',action='store_true')
     imp=sub.add_parser('import',help='Import an existing SQLite DB via the exact image online-backup contract'); _common(imp); _import_args(imp)
     recover=sub.add_parser('recover-import',help='Recover a verified failed import without overwriting or recopying the database'); _common(recover); _import_args(recover)
-    backup=sub.add_parser('backup',help='Create a verified SQLite backup with the exact image'); _common(backup)
-    migrate=sub.add_parser('migrate',help='Create required backup and run exact-image SQLite migration'); _common(migrate)
+    backup=sub.add_parser('backup',help='Create a verified SQLite database backup with the exact image'); _common(backup); _recovery_manifest_arg(backup)
+    migrate=sub.add_parser('migrate',help='Create required database backup and run exact-image SQLite migration'); _common(migrate); _recovery_manifest_arg(migrate)
     migrate.add_argument('--first-install',action='store_true'); migrate.add_argument('--run-as'); migrate.add_argument('--database-file')
     check=sub.add_parser('rollback-check',help='Verify that an exact rollback image accepts the current SQLite state'); _common(check)
     return parser
@@ -73,10 +90,13 @@ def main(argv: list[str]|None=None) -> int:
     args=build_parser().parse_args(argv)
     try:
         if args.command=='inventory': _print(sqlite_inventory(args.name),as_json=args.json); return 0
+        if args.command=='migrate' and getattr(args,'first_install',False) and getattr(args,'recovery_manifest',None):
+            raise DeploymentKitError("--recovery-manifest is supported only for existing-database SQLite migration, not --first-install.")
         production_classified = args.production or args.environment == 'production'
         request=normalize_sqlite_request(owner_repo=args.owner_repo,environment=args.environment,app_slug=args.app_slug,image=args.image,
             maintenance_environment=_parse_env(args.maintenance_env),run_as=getattr(args,'run_as',None),database_file=getattr(args,'database_file',None),
-            source_database=getattr(args,'source_database',None),first_install=getattr(args,'first_install',False))
+            source_database=getattr(args,'source_database',None),first_install=getattr(args,'first_install',False),
+            recovery_scope=_load_recovery_manifest(getattr(args,'recovery_manifest',None)))
         if args.command=='recover-import':
             plan=plan_sqlite_import_recovery(args.name,request,production=production_classified)
             _print({k:v for k,v in plan.items() if k!='request'},as_json=False)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mriekki/project-forge",
-  "version": "4.11.2",
+  "version": "4.13.0",
   "description": "Public consumer distribution and updater for Project Forge engineering assets.",
   "type": "module",
   "bin": {