dxcomplete 0.2.1 → 0.2.2

package/.env.example

@@ -1,10 +1,3 @@
-# Central service deployment
-DXC_MONGODB_URI=
-DXC_DATABASE_NAME=dxcomplete
-DXC_GOOGLE_CLIENT_ID=
-DXC_GOOGLE_CLIENT_SECRET=
-DXC_SERVICE_PROVISIONING_SECRET=
-
 # Workspace MCP deployment
 DXC_SERVICE_URL=
 DXC_SERVICE_CLIENT_ID=

package/README.md

@@ -2,6 +2,8 @@
 
 DX Complete installs a process, documentation, and MCP route scaffold into a Next.js workspace so a service can track decisions, requirements, tasks, changes, incidents, support, operations, and measurement over time.
 
+This public package is the workspace installer and client-side MCP surface. It does not include the central DX Complete service that stores records, manages OAuth, checks workspace membership, assigns readable IDs, or executes MCP tools. Installed workspaces connect to that hosted service with provisioned workspace credentials.
+
 ## Quick Start
 
 Install the scaffold into the current Next.js project:
@@ -12,6 +14,8 @@ npx dxcomplete init
 
 The command creates editable DX Complete documentation and process files under `dxcomplete/`, installs Next.js route wrappers under `pages/api/`, writes `vercel.json` compatibility settings, and creates `dxcomplete/workspace.json` as the workspace identity for that service.
 
+Before the hosted MCP route can be used, the workspace must be provisioned in DX Complete and given its workspace service URL, client ID, and client secret.
+
 The broader product premise is:
 
 ```text
@@ -108,47 +112,28 @@ The workspace identity is written to `dxcomplete/workspace.json` inside the inst
 DX Complete uses one package version, one workspace compatibility gate, and one surface fingerprint:
 
 - `packageVersion` is the npm package release version from `package.json`.
-- `workspaceCompatibility` is the installed workspace compatibility gate. It changes only when an installed workspace must update its route/proxy surface to keep talking safely to the central service.
+- `workspaceCompatibility` is the installed workspace compatibility gate. It changes only when an installed workspace must update its route/proxy surface to keep talking safely to the hosted DX Complete service.
 - `surfaceFingerprint` is an automatic hash of the live MCP tools, tool schemas, process guide, and on-demand doc references. It can change without requiring a package release or workspace upgrade.
 
 The MCP `surfaceVersion` field is a stable surface identifier. Use `surfaceFingerprint` for exact surface reconciliation and `workspaceCompatibility` for upgrade decisions.
 
-## Runtime and MCP
+## Workspace Runtime and MCP
 
-The documentation scaffold is the first milestone. The next layer is a hosted runtime and MCP server so DX Complete can coordinate its own records. The runtime now treats Workspace as the boundary for one service scope.
+The documentation scaffold is the first milestone. The runtime layer treats Workspace as the boundary for one service scope.
 
-The default MCP deployment model is one endpoint per workspace. A Next.js project repo installs DX Complete and exposes an MCP route for that workspace, but that workspace server does not open the database directly. It proxies auth and MCP requests to the central DX Complete service. Access is scoped by the installed repo's `dxcomplete/workspace.json`, authenticated actor identity, and workspace membership. Do not use a workspace environment variable for this boundary.
+The default MCP deployment model is one endpoint per workspace. A Next.js project repo installs DX Complete and exposes an MCP route for that workspace. That workspace route does not open the database directly and does not run the hosted DX Complete service. It proxies auth and MCP requests to that service. Access is scoped by the installed repo's `dxcomplete/workspace.json`, authenticated actor identity, and workspace membership. Do not use a workspace environment variable for this boundary.
 
-For the central service deployment, provide the database and Google OAuth configuration:
+For a workspace MCP deployment, provide only the hosted-service connection:
 
 ```sh
-DXC_MONGODB_URI=mongodb+srv://...
-DXC_DATABASE_NAME=dxcomplete
-DXC_GOOGLE_CLIENT_ID=...
-DXC_GOOGLE_CLIENT_SECRET=...
-DXC_SERVICE_PROVISIONING_SECRET=...
-```
-
-`DXC_MONGODB_URI` is a secret, `DXC_DATABASE_NAME` is environment-specific, `DXC_GOOGLE_CLIENT_ID` is a provisioning detail, `DXC_GOOGLE_CLIENT_SECRET` is a secret, and `DXC_SERVICE_PROVISIONING_SECRET` is a secret.
-
-For a workspace MCP deployment, provide only the central-service connection:
-
-```sh
-DXC_SERVICE_URL=https://dxcomplete.example
+DXC_SERVICE_URL=https://dxcomplete.directeddomains.com
 DXC_SERVICE_CLIENT_ID=...
 DXC_SERVICE_CLIENT_SECRET=...
 ```
 
-`DXC_SERVICE_URL` is environment-specific, `DXC_SERVICE_CLIENT_ID` is a provisioning detail, and `DXC_SERVICE_CLIENT_SECRET` is a secret. Workspace MCP deployments must not require `DXC_MONGODB_URI`, `DXC_GOOGLE_CLIENT_ID`, or `DXC_GOOGLE_CLIENT_SECRET`.
-
-Then build and check the runtime:
-
-```sh
-npm run build
-npm run runtime:check
-```
+`DXC_SERVICE_URL` is environment-specific, `DXC_SERVICE_CLIENT_ID` is a provisioning detail, and `DXC_SERVICE_CLIENT_SECRET` is a secret. Workspace MCP deployments must not require database credentials, OAuth provider secrets, or central-service provisioning secrets.
 
-The first runtime collections cover workspaces, statements, journal entries, environments, components, estimates, benefits, expectations, requirements, commitments, deferrals, tasks, changes, decisions, and risks. Use the MCP tools to create and link those records inside the intended workspace. Workspace-scoped lifecycle records receive a human-readable reference such as `REQ-0001` while UUID remains the primary key and link target.
+Once connected, the hosted DX Complete service stores records for the workspace. The first runtime collections cover workspaces, statements, journal entries, environments, components, estimates, benefits, expectations, requirements, commitments, deferrals, tasks, changes, decisions, and risks. Use the MCP tools to create and link those records inside the intended workspace. Workspace-scoped lifecycle records receive a human-readable reference such as `REQ-0001` while UUID remains the primary key and link target.
 
 Environment and Component records form the Operational Registry. The registry is an inventory of operational state: what exists in each environment, where it lives, and which secret names or locations are relevant. It is not monitoring, diagnostics, a secret vault, an event log, or a runbook engine. Secret pointers should identify stores and keys only; do not record secret values.
 
@@ -161,7 +146,7 @@ Useful MCP tools include:
 - `list_unread_dxcomplete_ticket_replies` to see which tickets have unread DX Complete replies without returning the reply body, and `read_dxcomplete_ticket` to open a ticket and mark those replies read.
 - `append_journal_note`, `read_journal`, `get_journal_entry`, and `append_journal_summary` for shared workspace context that has no dedicated record home.
 - `get_record`, `list_records`, and `list_linked_records` to inspect records and relationships.
-- `create_workspace`, `create_statement`, and `update_statement` to establish the workspace, service scope, and traceable source wording.
+- `create_statement` and `update_statement` to capture service-scope source wording.
 - `create_environment`, `update_environment`, `list_environments`, `create_component`, `update_component`, and `list_components` for the Operational Registry.
 - `create_expectation` and `update_expectation` for user-facing conditions of satisfaction, with prior versions preserved on update.
 - `create_requirement` and `update_requirement` for requirement work, with prior requirement versions preserved on update.
@@ -175,11 +160,7 @@ Useful MCP tools include:
 - `link_records` and `unlink_records` for explicit relationships when a typed tool does not already create or remove the link.
 - `archive_record` for cleanup without deleting evidence.
 
-Hosted MCP is exposed at `/api/mcp`. The workspace route uses Streamable HTTP, advertises OAuth metadata for remote MCP clients, proxies OAuth through the central service, sends users through Google OAuth, and then returns DX Complete bearer tokens scoped to the configured workspace. The installed repo supplies workspace identity through `dxcomplete/workspace.json`; the central service stores workspace memberships and executes MCP tools.
-
-The central service exposes internal routes under `/api/dxcomplete/service/*`. Workspace servers authenticate to those routes with `DXC_SERVICE_CLIENT_ID` and `DXC_SERVICE_CLIENT_SECRET`. The provisioning route creates the workspace record, seeds the Owner membership, and returns the one-time workspace service-client secret.
-
-For Google OAuth provisioning, set the callback URL to `/api/auth/callback/google` on the hosted workspace domain.
+Hosted MCP is exposed in the installed workspace app at `/api/mcp`. The workspace route uses Streamable HTTP, advertises OAuth metadata for remote MCP clients, proxies OAuth through the hosted DX Complete service, and returns DX Complete bearer tokens scoped to the configured workspace. The installed repo supplies workspace identity through `dxcomplete/workspace.json`; the hosted service stores workspace memberships and executes MCP tools.
 
 Use `runtime_status` to reconcile the MCP-facing contract. `surfaceFingerprint` is the single client-facing identity for the tools, tool schemas, process guide, and on-demand doc references together. `get_process_guide` and `get_doc` return the same `surfaceVersion` and `surfaceFingerprint`, so an MCP client can treat a mismatch as a stale or inconsistent surface and refresh before continuing.
 
@@ -191,23 +172,14 @@ The Journal is shared workspace context, not a private ticket. It is for useful
 
 The Operating Guide explains record routing by role. Engineer/Codex work defaults to Requirement -> Task. Tester evidence usually belongs in Task entries, review notes, Risk, Decision, or Journal. Operator work uses Change for run-side alterations, Incident for specific service-impacting occurrences, Problem for underlying or recurring causes, and Environment or Component for operational inventory. Support Agent work starts with DX Complete Ticket, then promotes to shared records only when needed.
 
-Run the hosted MCP smoke test after runtime changes:
-
-```sh
-npm run smoke:mcp:http
-```
-
-After updating a remote connector, compare its `runtime_status` fingerprint with the hosted smoke-test fingerprint before relying on newly added tools.
-
 ## Repository Structure
 
 ```text
-docs/                 Package documentation and draft model notes
-templates/process/    Installed process scaffold
+docs/                 Installed DX Complete documentation
+templates/process/    Installed editable process files
 templates/next/       Installed Next.js route wrappers
 templates/github/     Optional GitHub workflow placeholder
-src/                  TypeScript CLI, runtime, and MCP source
-dist/                 Runtime JavaScript CLI
+dist/                 Published CLI and workspace MCP proxy handler
 ```
 
 ## Design Principle

package/dist/cli.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 import { initProject } from "./init.js";
-import { checkRuntime } from "./runtime/check.js";
 import { upgradeProject } from "./upgrade.js";
 import { validateScaffold } from "./validate.js";
 import { DXCOMPLETE_PACKAGE_VERSION } from "./version.js";
@@ -82,11 +81,6 @@ async function main(argv) {
         process.exitCode = 1;
         return;
     }
-    if (args.command === "check-runtime") {
-        const result = await checkRuntime({ envFile: args.envFile });
-        console.log(JSON.stringify(result, null, 2));
-        return;
-    }
     throw new Error(`Unknown command "${args.command}".`);
 }
 function parseArgs(argv) {
@@ -128,19 +122,6 @@ function parseArgs(argv) {
             parsed.targetDir = arg.slice("--target=".length);
             continue;
         }
-        if (arg === "--env") {
-            const value = argv[index + 1];
-            if (!value) {
-                throw new Error("--env requires a file path.");
-            }
-            parsed.envFile = value;
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith("--env=")) {
-            parsed.envFile = arg.slice("--env=".length);
-            continue;
-        }
         if (arg === "--force") {
             parsed.force = true;
             continue;
@@ -181,17 +162,14 @@ Usage:
   dxcomplete init [--target <dir>] [--force] [--dry-run] [--no-github-workflow]
   dxcomplete upgrade [--target <dir>] [--apply] [--force]
   dxcomplete validate [--target <dir>]
-  dxcomplete check-runtime [--env <file>]
 
 Commands:
   init            Install the editable draft scaffold into a project.
   upgrade         Preview or apply compatibility-critical scaffold updates.
   validate        Validate the expected scaffold file shape.
-  check-runtime   Verify MongoDB connectivity and required collections.
 
 Options:
   --target <dir>          Target project directory. Defaults to the current directory.
-  --env <file>            Runtime env file. Defaults to .env.local when present.
   --apply                 Write upgrade changes. Upgrade previews by default.
   --force                 Overwrite existing scaffold files.
   --dry-run               Show what would be written without changing files.

package/dist/validate.js

@@ -62,39 +62,23 @@ function packageRequiredFiles() {
         ...processFiles.map((file) => path.join("templates", "process", file)),
         ...diagrams.map((file) => path.join("templates", "process", "diagrams", file)),
         ".env.example",
-        path.join("api", "mcp.js"),
-        path.join("api", "dxcomplete.js"),
-        path.join("api", "dxcomplete-service.js"),
-        path.join("api", "auth", "callback", "google.js"),
-        path.join("dxcomplete", "workspace.json"),
         path.join("templates", "AGENTS.md"),
-        path.join("scripts", "check-env-surface.mjs"),
-        path.join("scripts", "smoke-mcp-http.mjs"),
-        path.join("scripts", "runtime-work-order.mjs"),
-        path.join("scripts", "check-public-copy.mjs"),
-        path.join("scripts", "check-service-boundary.mjs"),
         path.join("templates", "next", "pages", "api", "mcp.js"),
         path.join("templates", "next", "pages", "api", "dxcomplete.js"),
         path.join("templates", "next", "pages", "api", "dxcomplete", "[...path].js"),
         path.join("templates", "next", "pages", "api", "auth", "callback", "google.js"),
         path.join("templates", "next", "vercel.json"),
         path.join("templates", "github", "workflows", "dxcomplete.yml"),
-        path.join("src", "cli.ts"),
-        path.join("src", "install-manifest.ts"),
-        path.join("src", "init.ts"),
-        path.join("src", "package-root.ts"),
-        path.join("src", "http", "server.ts"),
-        path.join("src", "http", "service.ts"),
-        path.join("src", "mcp", "server.ts"),
-        path.join("src", "runtime", "auth.ts"),
-        path.join("src", "runtime", "check.ts"),
-        path.join("src", "runtime", "config.ts"),
-        path.join("src", "runtime", "mongo.ts"),
-        path.join("src", "runtime", "records.ts"),
-        path.join("src", "runtime", "workspace.ts"),
-        path.join("src", "upgrade.ts"),
-        path.join("src", "version.ts"),
-        path.join("src", "validate.ts")
+        path.join("dist", "cli.js"),
+        path.join("dist", "init.js"),
+        path.join("dist", "install-manifest.js"),
+        path.join("dist", "package-root.js"),
+        path.join("dist", "http", "server.js"),
+        path.join("dist", "runtime", "actor.js"),
+        path.join("dist", "runtime", "workspace.js"),
+        path.join("dist", "upgrade.js"),
+        path.join("dist", "version.js"),
+        path.join("dist", "validate.js")
     ];
 }
 function installedRequiredFiles() {

package/docs/model.md

@@ -12,9 +12,9 @@ DX Complete = Decision Basis + Complete Engineering + Operations Measurement
 
 It should include cost and benefit reasoning before engineering begins, both build/change roles and run/service roles, and actual measurement after delivery where available.
 
-The current runtime scope decision is `Workspace`: the shared-runtime container for one service scope. The default MCP deployment model is one endpoint per workspace. Each installed project repo carries its workspace identity in editable DX Complete config and exposes one hosted MCP route for that workspace.
+The current runtime scope decision is `Workspace`: the hosted-record container for one service scope. The default MCP deployment model is one endpoint per workspace. Each installed project repo carries its workspace identity in editable DX Complete config and exposes one MCP route for that workspace.
 
-Workspace MCP deployments are not database runtimes. They proxy auth and MCP requests to the central DX Complete service. The central service owns database access, Google OAuth exchange, workspace membership, readable-ID allocation, and MCP tool execution. Separate database deployment may be revisited later, but workspace servers should not hold database credentials in the current model.
+Workspace MCP deployments are not database runtimes and do not install the hosted DX Complete service. They proxy auth and MCP requests to that service. The hosted service owns database access, OAuth exchange, workspace membership, readable-ID allocation, and MCP tool execution. Separate database deployment may be revisited later, but workspace servers should not hold database credentials in the current model.
 
 Workspace carries the service identity through its name, summary, and mode when useful. A separate service charter record is not part of the current model; if a presentation summary is needed, it should be derived from the workspace and current expectations.
 
@@ -38,7 +38,7 @@ This is a draft. The primary lifecycle object, object boundaries, role ownership
 
 Direction sets authority, priority, boundaries, and escalation paths.
 
-Workspace scope contains one service context and prevents records from different service scopes from mixing in the shared runtime. In the hosted model, the endpoint gets workspace scope from repo config, then the central service checks the authenticated actor identity and workspace authorization before executing tools.
+Workspace scope contains one service context and prevents records from different service scopes from mixing in the hosted record store. In the hosted model, the endpoint gets workspace scope from repo config, then the hosted DX Complete service checks the authenticated actor identity and workspace authorization before executing tools.
 
 Decision-basis work captures the initial statement and expected outcome, elicits expectations, requirements, and enough detail for useful estimates, attempts current-state cost visibility where relevant, estimates projected cost through `Estimate`, records expected value through `Benefits`, and supports Weigh. `Estimate` is the structured itemized cost record for Weigh. `Benefits` is the Owner-authored benefit record and may include quantified or qualitative benefit items. Decision records preserve rationale and linked inputs when a separate decision trail is useful.
 

package/docs/taxonomy.md

@@ -41,7 +41,7 @@ These concepts remain useful, but they are not separate runtime records in the c
 
 ## Current Lifecycle Hypothesis
 
-`Workspace` is the runtime scope object. It contains one service scope and is the boundary for shared database records. The default MCP deployment model is one endpoint per installed workspace, with workspace identity coming from DX Complete config and access constrained by authenticated actor plus workspace authorization.
+`Workspace` is the runtime scope object. It contains one service scope and is the boundary for hosted DX Complete records. The default MCP deployment model is one endpoint per installed workspace, with workspace identity coming from DX Complete config and access constrained by authenticated actor plus workspace authorization.
 
 Workspace-scoped lifecycle records use UUIDs as primary keys and links, while also carrying a human-readable reference such as `REQ-0001`. The readable reference is for people; it does not replace the UUID.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dxcomplete",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Install a Next.js workspace scaffold for DX Complete process records, MCP routes, and service lifecycle documentation.",
   "type": "module",
   "keywords": [
@@ -17,7 +17,7 @@
     "type": "git",
     "url": "git+https://github.com/DirectedDomains/dxcomplete.git"
   },
-  "homepage": "https://github.com/DirectedDomains/dxcomplete#readme",
+  "homepage": "https://dxcomplete.directeddomains.com",
   "bugs": {
     "url": "https://github.com/DirectedDomains/dxcomplete/issues"
   },
@@ -28,18 +28,31 @@
     "./http": {
       "types": "./dist/http/server.d.ts",
       "default": "./dist/http/server.js"
-    },
-    "./service": {
-      "types": "./dist/http/service.d.ts",
-      "default": "./dist/http/service.js"
     }
   },
   "files": [
     ".env.example",
-    "dist",
+    "dist/cli.d.ts",
+    "dist/cli.js",
+    "dist/http/server.d.ts",
+    "dist/http/server.js",
+    "dist/init.d.ts",
+    "dist/init.js",
+    "dist/install-manifest.d.ts",
+    "dist/install-manifest.js",
+    "dist/package-root.d.ts",
+    "dist/package-root.js",
+    "dist/runtime/actor.d.ts",
+    "dist/runtime/actor.js",
+    "dist/runtime/workspace.d.ts",
+    "dist/runtime/workspace.js",
+    "dist/upgrade.d.ts",
+    "dist/upgrade.js",
+    "dist/validate.d.ts",
+    "dist/validate.js",
+    "dist/version.d.ts",
+    "dist/version.js",
     "docs",
-    "scripts",
-    "src",
     "templates",
     "website",
     "README.md"
@@ -50,20 +63,7 @@
     "check:public-copy": "node scripts/check-public-copy.mjs",
     "check:env-surface": "node scripts/check-env-surface.mjs",
     "check:service-boundary": "node scripts/check-service-boundary.mjs",
-    "smoke:mcp:http": "node scripts/smoke-mcp-http.mjs --depth=light",
-    "smoke:mcp:http:light": "node scripts/smoke-mcp-http.mjs --depth=light",
-    "smoke:mcp:http:deep": "node scripts/smoke-mcp-http.mjs --depth=deep",
-    "smoke:mcp:http:full": "node scripts/smoke-mcp-http.mjs --depth=deep",
-    "smoke:mcp:http:surface": "node scripts/smoke-mcp-http.mjs --area=surface",
-    "smoke:mcp:http:docs": "node scripts/smoke-mcp-http.mjs --area=docs",
-    "smoke:mcp:http:records": "node scripts/smoke-mcp-http.mjs --area=records",
-    "smoke:mcp:http:weigh": "node scripts/smoke-mcp-http.mjs --area=weigh",
-    "smoke:mcp:http:change": "node scripts/smoke-mcp-http.mjs --area=change",
-    "smoke:mcp:http:tickets": "node scripts/smoke-mcp-http.mjs --area=tickets",
-    "smoke:mcp:http:journal": "node scripts/smoke-mcp-http.mjs --area=journal",
-    "runtime:work-order": "node scripts/runtime-work-order.mjs",
-    "validate:package": "node dist/cli.js validate --target . --package-layout",
-    "runtime:check": "node dist/cli.js check-runtime"
+    "validate:package": "node dist/cli.js validate --target . --package-layout"
   },
   "engines": {
     "node": "22.x"

package/templates/process/README.md

@@ -4,7 +4,7 @@ This directory is an editable draft scaffold for a DX Complete model.
 
 The current model is not final. Update these files as the decision-basis, engineering, service, roles, workflows, object taxonomy, and controls become clearer.
 
-The current scope commitment is that a Workspace contains one service scope. Statements, journal entries, decisions, requirements, work, cost, benefit, support, operations, and measurement records should be understood inside that workspace unless a project explicitly decides otherwise. The default runtime shape is one hosted MCP endpoint for that installed workspace, with workspace identity coming from DX Complete config and access constrained by authenticated actor identity plus workspace authorization.
+The current scope commitment is that a Workspace contains one service scope. Statements, journal entries, decisions, requirements, work, cost, benefit, support, operations, and measurement records should be understood inside that workspace unless a project explicitly decides otherwise. The default runtime shape is one MCP endpoint for that installed workspace, with workspace identity coming from DX Complete config and access constrained by authenticated actor identity plus workspace authorization.
 
 ## Files
 

package/dist/http/service.d.ts

@@ -1,7 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-export declare function closeDxcompleteServiceRuntime(): Promise<void>;
-export declare function closeDxcompleteHttpRuntime(): Promise<void>;
-export default function handleDxcompleteServiceRequest(req: IncomingMessage & {
-    body?: unknown;
-    query?: Record<string, unknown>;
-}, res: ServerResponse): Promise<void>;