@tomflow/proflow-task-store-sqlite 0.1.0 → 0.1.2

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @tomflow/proflow-task-store-sqlite
+
+## 0.1.2
+
+### Patch Changes
+
+- Real-1 final remediation and black-box release closure
+
+## 0.1.1
+
+### Patch Changes
+
+- Close the Real-1 global Platform control-plane contract across every published ProFlow package. Platform CLI now owns one durable global Workspace binding with canonical identity, cross-process operation locking, cwd/`--workspace` install targeting, cross-directory instance commands, whole-instance uninstall/rebind, and deterministic npm/yarn/pnpm Workspace package-manager selection. Every package-owned install entry, including newly generated Module Template packages, delegates to the Shell-global `platform` command and fails closed when that global CLI is unavailable; Deployment Conformance and the formal test plans mechanically enforce the same rule across all 24 packages.

package/dist/deployment/adapter.d.ts

@@ -1,47 +1,235 @@
+export declare function createBehaviorAdapter(config?: Record<string, string>): {
+    describe: () => {
+        result: {
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "SUCCEEDED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            checks?: unknown[];
+        };
+        observedEffects: never[];
+    };
+    preflight: () => {
+        result: {
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "SUCCEEDED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            checks?: unknown[];
+        } | {
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "ACTION_REQUIRED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            actionRequired: {
+                action: string;
+                description: string;
+            };
+            checks?: unknown[];
+        } | {
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "BLOCKED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            error: {
+                code: "VERIFY_FAILED";
+                message: string;
+                retryable: boolean;
+            };
+            checks?: unknown[];
+        };
+        observedEffects: never[];
+    };
+    verify: () => {
+        result: {
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "SUCCEEDED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            checks?: unknown[];
+        } | {
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "ACTION_REQUIRED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            actionRequired: {
+                action: string;
+                description: string;
+            };
+            checks?: unknown[];
+        } | {
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "BLOCKED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            error: {
+                code: "VERIFY_FAILED";
+                message: string;
+                retryable: boolean;
+            };
+            checks?: unknown[];
+        };
+        observedEffects: never[];
+    };
+    doctor: () => {
+        result: {
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "SUCCEEDED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            checks?: unknown[];
+        } | {
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "ACTION_REQUIRED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            actionRequired: {
+                action: string;
+                description: string;
+            };
+            checks?: unknown[];
+        } | {
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "BLOCKED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            error: {
+                code: "VERIFY_FAILED";
+                message: string;
+                retryable: boolean;
+            };
+            checks?: unknown[];
+        };
+        observedEffects: never[];
+    };
+};
 export declare const behaviorAdapter: {
-    readonly describe: () => {
+    describe: () => {
         result: {
-            readonly contract: "deployment.result.v1";
-            readonly ok: true;
-            readonly status: "SUCCEEDED";
-            readonly moduleRef: "task-store-sqlite";
-            readonly moduleVersion: "0.1.0";
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "SUCCEEDED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            checks?: unknown[];
         };
         observedEffects: never[];
     };
-    readonly preflight: () => {
+    preflight: () => {
         result: {
-            readonly contract: "deployment.result.v1";
-            readonly ok: true;
-            readonly status: "SUCCEEDED";
-            readonly moduleRef: "task-store-sqlite";
-            readonly moduleVersion: "0.1.0";
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "SUCCEEDED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            checks?: unknown[];
+        } | {
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "ACTION_REQUIRED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            actionRequired: {
+                action: string;
+                description: string;
+            };
+            checks?: unknown[];
+        } | {
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "BLOCKED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            error: {
+                code: "VERIFY_FAILED";
+                message: string;
+                retryable: boolean;
+            };
+            checks?: unknown[];
         };
         observedEffects: never[];
     };
-    readonly verify: () => {
+    verify: () => {
         result: {
             contract: "deployment.result.v1";
-            ok: true;
+            ok: boolean;
             status: "SUCCEEDED";
             moduleRef: "task-store-sqlite";
-            moduleVersion: "0.1.0";
-            checks: {
-                id: string;
-                status: string;
+            moduleVersion: "0.1.2";
+            checks?: unknown[];
+        } | {
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "ACTION_REQUIRED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            actionRequired: {
+                action: string;
+                description: string;
+            };
+            checks?: unknown[];
+        } | {
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "BLOCKED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            error: {
+                code: "VERIFY_FAILED";
                 message: string;
-            }[];
+                retryable: boolean;
+            };
+            checks?: unknown[];
         };
         observedEffects: never[];
     };
-    readonly doctor: () => {
+    doctor: () => {
         result: {
-            readonly contract: "deployment.result.v1";
-            readonly ok: true;
-            readonly status: "SUCCEEDED";
-            readonly moduleRef: "task-store-sqlite";
-            readonly moduleVersion: "0.1.0";
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "SUCCEEDED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            checks?: unknown[];
+        } | {
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "ACTION_REQUIRED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            actionRequired: {
+                action: string;
+                description: string;
+            };
+            checks?: unknown[];
+        } | {
+            contract: "deployment.result.v1";
+            ok: boolean;
+            status: "BLOCKED";
+            moduleRef: "task-store-sqlite";
+            moduleVersion: "0.1.2";
+            error: {
+                code: "VERIFY_FAILED";
+                message: string;
+                retryable: boolean;
+            };
+            checks?: unknown[];
         };
         observedEffects: never[];
     };
 };
+export declare function createProductionBinding(input: {
+    config: Record<string, string>;
+}): {
+    behaviorAdapter: Record<string, unknown>;
+};

package/dist/deployment/adapter.js

@@ -1,26 +1,121 @@
+import { existsSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
 import { descriptor } from "./descriptor.js";
-const result = {
+const REQUIRED_TABLES = [
+    "schema_migrations",
+    "task_groups",
+    "tasks",
+    "nodes",
+    "task_role_bindings",
+    "node_execution_history",
+    "task_documents",
+    "task_messages",
+    "task_events",
+    "idempotency_records",
+];
+const success = (checks) => ({
     contract: "deployment.result.v1",
     ok: true,
     status: "SUCCEEDED",
     moduleRef: descriptor.moduleRef,
     moduleVersion: descriptor.moduleVersion,
-};
-export const behaviorAdapter = {
-    describe: () => ({ result, observedEffects: [] }),
-    preflight: () => ({ result, observedEffects: [] }),
-    verify: () => ({
-        result: {
-            ...result,
-            checks: [
-                {
-                    id: "sqlite-integrity-pass",
-                    status: "PASS",
-                    message: "SQLite integrity verification is available",
-                },
-            ],
+    ...(checks === undefined ? {} : { checks }),
+});
+const actionRequired = (description, checks) => ({
+    contract: "deployment.result.v1",
+    ok: false,
+    status: "ACTION_REQUIRED",
+    moduleRef: descriptor.moduleRef,
+    moduleVersion: descriptor.moduleVersion,
+    actionRequired: { action: "configure-task-store", description },
+    ...(checks === undefined ? {} : { checks }),
+});
+const blocked = (message, checks) => ({
+    contract: "deployment.result.v1",
+    ok: false,
+    status: "BLOCKED",
+    moduleRef: descriptor.moduleRef,
+    moduleVersion: descriptor.moduleVersion,
+    error: { code: "VERIFY_FAILED", message, retryable: true },
+    ...(checks === undefined ? {} : { checks }),
+});
+function inspect(databasePath) {
+    if (!databasePath)
+        return { ok: false, message: "databasePath is required" };
+    if (!existsSync(databasePath)) {
+        return {
+            ok: false,
+            message: `Task SQLite database does not exist at ${databasePath}`,
+        };
+    }
+    let database;
+    try {
+        database = new DatabaseSync(databasePath, { readOnly: true });
+        const integrity = database.prepare("PRAGMA integrity_check").get();
+        const tables = new Set(database
+            .prepare("SELECT name FROM sqlite_master WHERE type='table'")
+            .all().map((row) => row.name));
+        const missing = REQUIRED_TABLES.filter((table) => !tables.has(table));
+        if (integrity?.integrity_check !== "ok") {
+            return {
+                ok: false,
+                message: `SQLite integrity_check returned ${integrity?.integrity_check ?? "unknown"}`,
+            };
+        }
+        if (missing.length > 0) {
+            return {
+                ok: false,
+                message: `Task SQLite schema is missing tables: ${missing.join(", ")}`,
+            };
+        }
+        return {
+            ok: true,
+            message: "Task SQLite schema is present and integrity_check is ok",
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            message: error instanceof Error
+                ? error.message
+                : "Task SQLite reality could not be read",
+        };
+    }
+    finally {
+        database?.close();
+    }
+}
+export function createBehaviorAdapter(config = {}) {
+    const resultForReality = (reality, checks) => reality.ok
+        ? success(checks)
+        : config.databasePath
+            ? blocked(reality.message, checks)
+            : actionRequired(reality.message, checks);
+    return {
+        describe: () => ({ result: success(), observedEffects: [] }),
+        preflight: () => {
+            const reality = inspect(config.databasePath);
+            return { result: resultForReality(reality), observedEffects: [] };
+        },
+        verify: () => {
+            const reality = inspect(config.databasePath);
+            const check = {
+                id: "sqlite-integrity-pass",
+                status: reality.ok ? "PASS" : "FAIL",
+                message: reality.message,
+            };
+            return {
+                result: resultForReality(reality, [check]),
+                observedEffects: [],
+            };
+        },
+        doctor: () => {
+            const reality = inspect(config.databasePath);
+            return { result: resultForReality(reality), observedEffects: [] };
         },
-        observedEffects: [],
-    }),
-    doctor: () => ({ result, observedEffects: [] }),
-};
+    };
+}
+export const behaviorAdapter = createBehaviorAdapter();
+export function createProductionBinding(input) {
+    return { behaviorAdapter: createBehaviorAdapter(input.config) };
+}

package/dist/deployment/descriptor.d.ts

@@ -3,7 +3,7 @@ export declare const descriptor: {
     readonly contractVersion: "1.0.0";
     readonly moduleRef: "task-store-sqlite";
     readonly packageName: "@tomflow/proflow-task-store-sqlite";
-    readonly moduleVersion: "0.1.0";
+    readonly moduleVersion: "0.1.2";
     readonly kind: "library";
     readonly templateVersion: "1.0.0";
     readonly platformCompatibility: ">=1.0.0 <2.0.0";

package/dist/deployment/descriptor.js

@@ -3,7 +3,7 @@ export const descriptor = {
     contractVersion: "1.0.0",
     moduleRef: "task-store-sqlite",
     packageName: "@tomflow/proflow-task-store-sqlite",
-    moduleVersion: "0.1.0",
+    moduleVersion: "0.1.2",
     kind: "library",
     templateVersion: "1.0.0",
     platformCompatibility: ">=1.0.0 <2.0.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomflow/proflow-task-store-sqlite",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -19,11 +19,11 @@
     "self-install.mjs"
   ],
   "dependencies": {
-    "@tomflow/proflow-task-orchestration": "^0.1.0",
-    "@tomflow/proflow-module-contract": "^0.1.0"
+    "@tomflow/proflow-module-contract": "^0.1.1",
+    "@tomflow/proflow-task-orchestration": "^0.1.1"
   },
   "devDependencies": {
-    "@tomflow/proflow-task-migration-runner": "^0.1.0"
+    "@tomflow/proflow-task-migration-runner": "^0.1.2"
   },
   "description": "Provides the node:sqlite store and repository adapters for Task-owned structured facts.",
   "keywords": [

package/proflow.module.json

@@ -3,7 +3,7 @@
 	"contractVersion": "1.0.0",
 	"moduleRef": "task-store-sqlite",
 	"packageName": "@tomflow/proflow-task-store-sqlite",
-	"moduleVersion": "0.1.0",
+	"moduleVersion": "0.1.2",
 	"kind": "library",
 	"templateVersion": "1.0.0",
 	"platformCompatibility": ">=1.0.0 <2.0.0",

package/self-install.mjs

@@ -11,16 +11,24 @@ if (command !== "install" || rest.length > 0) {
 	process.stderr.write(usage);
 	process.exit(2);
 }
-const executable = process.platform === "win32" ? "npx.cmd" : "npx";
+const executable = process.platform === "win32" ? "platform.cmd" : "platform";
 const result = spawnSync(
 	executable,
 	[
-		"--yes",
-		"@tomflow/proflow-platform-cli",
 		"install",
 		"@tomflow/proflow-task-store-sqlite",
+		"--workspace",
+		process.cwd(),
 	],
 	{ cwd: process.cwd(), env: process.env, stdio: "inherit" },
 );
-if (result.error) throw result.error;
+if (result.error) {
+	if (result.error.code === "ENOENT") {
+		process.stderr.write(
+			"GLOBAL_PLATFORM_CLI_REQUIRED: install @tomflow/proflow-platform-cli globally before package-owned install\n",
+		);
+		process.exit(127);
+	}
+	throw result.error;
+}
 process.exit(result.status ?? 1);