archgraph-argo 0.11.0 → 0.12.0

package/argo/scripts/ea-qea-sync.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+'use strict';
+
+// WP2791 Node direct .qea projection CLI (no EA, no third-party deps).
+//   node argo/scripts/ea-qea-sync.js --graph <json> --qea <file.qea> --mode import|sync|full|export|watch
+//   [--delete-confirm-file <f> | -y] [--dry-run] [--snapshot-dir <dir>] [--out <file>] [--no-backup]
+//
+// import/sync : project design/KG graph into the .qea (update-in-place, batch INSERT,
+// full        : clear projection-owned content (kg_sync_meta + ArchGraph Sync subtree) then
+//               unchanged fingerprint skip, opt-in EA-only delete with confirmation).
+// export      : read .qea back into graph-shaped JSON (roundtrip comparable).
+// watch       : on graph JSON change, run sync (fs.watch + polling fallback).
+// Every write first snapshots the target as <file>_before_sync_<ts> unless --no-backup.
+
+const path = require('node:path');
+const fs = require('node:fs');
+const lib = require(path.join(__dirname, 'ea-qea-sync-lib.js'));
+
+function parseArgs(argv) {
+  const args = { mode: 'sync', graph: '', qea: '', allowDelete: false, deleteConfirmFile: '', dryRun: false, snapshotDir: '', out: '', noBackup: false, intervalMs: 2000 };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    const next = () => (i + 1 < argv.length ? argv[++i] : '');
+    if (a === '--graph') { args.graph = next(); }
+    else if (a === '--qea') { args.qea = next(); }
+    else if (a === '--mode') { args.mode = next(); }
+    else if (a === '--delete-confirm-file') { args.deleteConfirmFile = next(); args.allowDelete = true; }
+    else if (a === '-y' || a === '--yes') { args.allowDelete = true; }
+    else if (a === '--dry-run') { args.dryRun = true; }
+    else if (a === '--snapshot-dir') { args.snapshotDir = next(); }
+    else if (a === '--out') { args.out = next(); }
+    else if (a === '--no-backup') { args.noBackup = true; }
+    else if (a === '--interval') { args.intervalMs = Number(next()) || 2000; }
+    else if (a.startsWith('-')) { /* ignore unknown */ }
+    else if (args.modeSet === undefined) { /* positional not used */ }
+  }
+  return args;
+}
+
+function readGraph(jsonPath) {
+  const raw = fs.readFileSync(jsonPath, 'utf8').replace(/^\uFEFF/, '');
+  return JSON.parse(raw);
+}
+function confirmDelete(args) {
+  if (args.allowDelete) { return true; }
+  if (args.deleteConfirmFile) {
+    try {
+      const text = fs.readFileSync(args.deleteConfirmFile, 'utf8').trim().toLowerCase();
+      return text.indexOf('delete') >= 0;
+    } catch { return false; }
+  }
+  return false;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const cwd = process.cwd();
+  const graphPath = path.resolve(cwd, args.graph || 'design/KG/SystemArchitecture.json');
+  const qeaPath = path.resolve(cwd, args.qea || 'archgraph.qea');
+  if (!fs.existsSync(qeaPath)) {
+    console.error('qea not found: ' + qeaPath);
+    process.exit(2);
+  }
+  if (args.mode === 'export') {
+    const graph = lib.exportQeaToGraph(qeaPath);
+    const text = JSON.stringify(graph, null, 2);
+    if (args.out) { fs.writeFileSync(path.resolve(cwd, args.out), text, 'utf8'); console.log('export written to ' + args.out); }
+    else { console.log(text); }
+    return;
+  }
+  if (!fs.existsSync(graphPath)) {
+    console.error('graph not found: ' + graphPath);
+    process.exit(2);
+  }
+  const graph = readGraph(graphPath);
+  if (args.mode === 'watch') {
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      runOnce(args, graphPath, qeaPath);
+      const m0 = statHash(graphPath);
+      await sleep(args.intervalMs);
+      const m1 = statHash(graphPath);
+      if (m0 !== m1) { continue; } // changed while waiting -> immediate re-sync
+    }
+  } else {
+    runOnce(args, graphPath, qeaPath);
+  }
+}
+function statHash(p) {
+  try { const st = fs.statSync(p); return st.size + ':' + st.mtimeMs; } catch { return 'gone'; }
+}
+function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
+function runOnce(args, graphPath, qeaPath) {
+  const graph = readGraph(graphPath);
+  let snapshot = null;
+  if (!args.dryRun && !args.noBackup) {
+    snapshot = lib.snapshotQea(qeaPath, args.snapshotDir || undefined);
+  }
+  const res = args.mode === 'full'
+    ? lib.fullProjection(graph, qeaPath, { dryRun: args.dryRun })
+    : lib.syncGraphToQea(graph, qeaPath, { dryRun: args.dryRun, allowDelete: confirmDelete(args) });
+  const mode = args.dryRun ? 'dry-run' : 'sync';
+  console.log(JSON.stringify({ mode, graph: graphPath, qea: qeaPath, snapshot, result: res }, null, 2));
+}
+
+main().catch((e) => {
+  console.error('ea-qea-sync failed: ' + (e && e.message));
+  process.exit(1);
+});

package/argo/scripts/systemarchitecture-mcp-server.js

@@ -1,5 +1,6 @@
 const fs = require('node:fs');
 const path = require('node:path');
+const { spawn } = require('node:child_process');
 const readline = require('node:readline');
 const crypto = require('node:crypto');
 
@@ -1615,6 +1616,25 @@ async function buildMutationResult(context, mutations, write) {
   writeGraph(context.graphPath.absolutePath, mutationResult.document);
   result.written = true;
 
+  // WP2791: .qea projection parallel to the Neo4j trigger — non-fatal, best-effort.
+  {
+    const qeaTarget = resolveQeaProjectionTarget(context);
+    if (qeaTarget) {
+      try {
+        const projection = await runQeaProjection(qeaTarget);
+        if (projection.ok) {
+          result.qeaProjection = { status: 'passed', qea: qeaTarget.qeaPath, ms: projection.ms };
+        } else {
+          result.qeaProjection = { status: 'failed', qea: qeaTarget.qeaPath, error: projection.error || ('exit ' + projection.code), ms: projection.ms };
+          result.warnings = addUnique(result.warnings || [], ['ea-qea projection failed (non-fatal): ' + (projection.error || ('exit code ' + projection.code))]);
+        }
+      } catch (error) {
+        result.qeaProjection = { status: 'failed', error: String(error && error.message ? error.message : error) };
+        result.warnings = addUnique(result.warnings || [], ['ea-qea projection error (non-fatal): ' + String(error && error.message ? error.message : error)]);
+      }
+    }
+  }
+
   if (shouldSyncCanonicalGraphToNeo4j(context.graphPath.relativePath)) {
     try {
       const syncResult = await syncArchitectureToNeo4j({
@@ -1812,6 +1832,59 @@ function summarizeDocument(document) {
   };
 }
 
+// --- WP2791: post-canonical-write .qea projection (parallel to Neo4j sync, non-fatal) ---
+// Target resolution (decision qea-full-wholefile-argo-scripts-no-config): env ARGO_EA_QEA >
+// the single *.qea at the workspace root (0/many -> no-op with an explicit log). NO config file.
+// Projection script runs from argo/scripts (same package as the MCP runtime), so a workspace
+// does not need to ship its own projection script (bundled argo/scripts module).
+function resolveQeaProjectionTarget(context) {
+  try {
+    const workspaceRoot = String(context && context.workspaceRoot ? context.workspaceRoot : '');
+    if (!workspaceRoot || !fs.existsSync(workspaceRoot)) { return null; }
+    const graphAbsolute = context.graphPath && context.graphPath.absolutePath ? context.graphPath.absolutePath : null;
+    if (!graphAbsolute || !fs.existsSync(graphAbsolute)) { return null; }
+    const pick = (p) => (p && fs.existsSync(p) ? path.resolve(p) : null);
+    let qeaPath = pick(process.env.ARGO_EA_QEA);
+    if (qeaPath) { return { qeaPath, graphPath: graphAbsolute, workspaceRoot }; }
+    let qeas = [];
+    try { qeas = fs.readdirSync(workspaceRoot).filter((n) => n.toLowerCase().endsWith('.qea')); } catch { /* ignore */ }
+    if (qeas.length === 1) {
+      return { qeaPath: path.resolve(workspaceRoot, qeas[0]), graphPath: graphAbsolute, workspaceRoot };
+    }
+    console.log('[ea-qea] projection target: none' + (qeas.length > 1 ? ' (' + qeas.length + ' *.qea found; expected exactly one or ARGO_EA_QEA)' : '') + ' in ' + workspaceRoot);
+    return null;
+  } catch (error) {
+    console.log('[ea-qea] projection target resolution failed: ' + String(error && error.message ? error.message : error));
+    return null;
+  }
+}
+
+function runQeaProjection(target) {
+  return new Promise((resolve) => {
+    const script = path.join(__dirname, 'ea-qea-sync.js');
+    if (!fs.existsSync(script)) {
+      resolve({ ok: false, error: 'argo/scripts/ea-qea-sync.js missing', ms: 0 });
+      return;
+    }
+    const snapshotDir = path.join(target.workspaceRoot, '.argo', 'temp', 'qea-backups');
+    const args = [script, '--mode', 'sync', '--graph', target.graphPath, '--qea', target.qeaPath, '--snapshot-dir', snapshotDir];
+    const started = Date.now();
+    let stderr = '';
+    let child;
+    try {
+      child = spawn(process.execPath, args, { cwd: target.workspaceRoot, windowsHide: true });
+    } catch (error) {
+      resolve({ ok: false, error: String(error && error.message ? error.message : error), ms: Date.now() - started });
+      return;
+    }
+    child.stderr.on('data', (d) => { stderr += String(d); });
+    child.on('error', (err) => resolve({ ok: false, error: String(err && err.message ? err.message : err), ms: Date.now() - started, stderr: stderr.slice(0, 600) }));
+    child.on('close', (code) => {
+      resolve({ ok: code === 0, code, ms: Date.now() - started, stderr: stderr.slice(0, 600) });
+    });
+  });
+}
+
 function writeGraph(graphPath, document) {
   const tempPath = `${graphPath}.${process.pid}.${Date.now()}.tmp`;
   fs.writeFileSync(tempPath, `${JSON.stringify(document, null, 2)}\n`, 'utf8');

package/install-argo.ps1

@@ -26,10 +26,7 @@ param(
     [string]$OpenClawRepoRoot = '',
     [switch]$SkipOpenClaw,
     [string]$McpPath,
-    [string]$GraphMcpUrl = 'https://argo.derekworkspacev5.com/mcp',
-    [switch]$SkipEaWeb,
-    [int]$EaWebPort = 8787,
-    [string]$EaWebRoot = ''
+    [string]$GraphMcpUrl = 'https://argo.derekworkspacev5.com/mcp'
 )
 
 $ErrorActionPreference = 'Stop'
@@ -740,37 +737,37 @@ Write-Host '==> Deploying Argo toolchain'
 
 $schemaSrc = Join-Path $argoDir 'schema'
 $schemaDest = Join-Path $ArgoRoot 'schema'
-Write-Host "[1/23] argo\schema -> $schemaDest"
+Write-Host "[1/22] argo\schema -> $schemaDest"
 Copy-Tree -Source $schemaSrc -Destination $schemaDest
 
 $scriptsSrc = Join-Path $argoDir 'scripts'
 $scriptsDest = Join-Path $ArgoRoot 'scripts'
-Write-Host "[2/23] argo\scripts -> $scriptsDest"
+Write-Host "[2/22] argo\scripts -> $scriptsDest"
 Copy-Tree -Source $scriptsSrc -Destination $scriptsDest
 
 $defaultsSrc = Join-Path $argoDir 'defaults'
 $defaultsDest = Join-Path $ArgoRoot 'defaults'
-Write-Host "[3/23] argo\defaults -> $defaultsDest"
+Write-Host "[3/22] argo\defaults -> $defaultsDest"
 Copy-Tree -Source $defaultsSrc -Destination $defaultsDest
 
 $skillSrc = Join-Path (Join-Path $argoDir 'skills') 'argo-init'
 $skillDest = Join-Path $SkillsRoot 'argo-init'
-Write-Host "[4/23] argo\skills\argo-init -> $skillDest"
+Write-Host "[4/22] argo\skills\argo-init -> $skillDest"
 Copy-Tree -Source $skillSrc -Destination $skillDest
 
 $ruleSrc = Join-Path (Join-Path $argoDir 'rules') 'archgraph.instructions.md'
 $ruleDest = Join-Path $PromptsRoot 'archgraph.instructions.md'
-Write-Host "[5/23] argo\rules\archgraph.instructions.md -> $ruleDest"
+Write-Host "[5/22] argo\rules\archgraph.instructions.md -> $ruleDest"
 New-Item -ItemType Directory -Force -Path $PromptsRoot | Out-Null
 Copy-Item -Force -Path $ruleSrc -Destination $ruleDest
 
 $depsSrc = Join-Path $argoDir 'package.json'
 $depsDest = Join-Path $ArgoRoot 'package.json'
-Write-Host "[6/23] argo\package.json -> $depsDest"
+Write-Host "[6/22] argo\package.json -> $depsDest"
 Copy-Item -Force -Path $depsSrc -Destination $depsDest
 
 $cursorSkillDest = Join-Path $CursorSkillsRoot 'argo-init'
-Write-Host "[7/23] argo\skills\argo-init -> $cursorSkillDest (Cursor)"
+Write-Host "[7/22] argo\skills\argo-init -> $cursorSkillDest (Cursor)"
 Copy-Tree -Source $skillSrc -Destination $cursorSkillDest
 
 $mcpBridgeSrc = Join-Path $argoDir 'mcp-bridges'
@@ -779,29 +776,29 @@ Write-Host "  argo\mcp-bridges -> $mcpBridgeDest (Cursor graph-mcp stdio bridge)
 Copy-Tree -Source $mcpBridgeSrc -Destination $mcpBridgeDest
 
 $openCodeSkillDest = Join-Path $OpenCodeSkillsRoot 'argo-init'
-Write-Host "[8/23] argo\skills\argo-init -> $openCodeSkillDest (OpenCode)"
+Write-Host "[8/22] argo\skills\argo-init -> $openCodeSkillDest (OpenCode)"
 Copy-Tree -Source $skillSrc -Destination $openCodeSkillDest
 
-Write-Host "[9/23] argo\rules\archgraph.instructions.md -> $OpenCodeAgentsPath (OpenCode global AGENTS.md)"
+Write-Host "[9/22] argo\rules\archgraph.instructions.md -> $OpenCodeAgentsPath (OpenCode global AGENTS.md)"
 Add-AgentsRule -AgentsPath $OpenCodeAgentsPath -RulePath $ruleSrc
 
 $agentsSrc = Join-Path $argoDir 'agents'
-Write-Host "[10/23] argo\agents -> $CopilotAgentsRoot (Copilot user-level)"
+Write-Host "[10/22] argo\agents -> $CopilotAgentsRoot (Copilot user-level)"
 Copy-Agents -Source $agentsSrc -Destination $CopilotAgentsRoot
 
-Write-Host "[11/23] argo\agents -> $CursorAgentsRoot (Cursor user-level, converted to .md)"
+Write-Host "[11/22] argo\agents -> $CursorAgentsRoot (Cursor user-level, converted to .md)"
 Copy-Agents -Source $agentsSrc -Destination $CursorAgentsRoot -Target cursor
 
-Write-Host "[12/23] argo\agents -> $OpenCodeAgentsRoot (OpenCode user-level, converted to .md)"
+Write-Host "[12/22] argo\agents -> $OpenCodeAgentsRoot (OpenCode user-level, converted to .md)"
 Copy-Agents -Source $agentsSrc -Destination $OpenCodeAgentsRoot -Target opencode
 
 $pluginsSrc = Join-Path $argoDir 'plugins'
-Write-Host "[13/23] argo\plugins -> $PluginsRoot (Argo opencode plugins)"
+Write-Host "[13/22] argo\plugins -> $PluginsRoot (Argo opencode plugins)"
 Copy-Tree -Source $pluginsSrc -Destination $PluginsRoot
 
 $cursorRuleSrc = Join-Path (Join-Path $argoDir 'rules') 'archgraph.instructions.md'
 $cursorRuleDest = Join-Path $CursorRulesRoot 'archgraph.mdc'
-Write-Host "[14/23] argo\rules\archgraph.instructions.md -> $cursorRuleDest (Cursor global rule, alwaysApply)"
+Write-Host "[14/22] argo\rules\archgraph.instructions.md -> $cursorRuleDest (Cursor global rule, alwaysApply)"
 New-Item -ItemType Directory -Force -Path $CursorRulesRoot | Out-Null
 Convert-RuleFile -SourceFile $cursorRuleSrc -DestinationFile $cursorRuleDest
 
@@ -813,16 +810,16 @@ if ($SkipDsh) {
     $patchPath = Join-Path $DshHome 'cordis.patch.yml'
     $argoServer = (Join-Path $ArgoRoot 'scripts\argo-mcp-server.js').Replace('\', '/')
 
-    Write-Host "[15/23] argo\rules\archgraph.instructions.md -> $DshHome\AGENTS.md (DeepSeek Harness user-global rule, frontmatter stripped)"
+    Write-Host "[15/22] argo\rules\archgraph.instructions.md -> $DshHome\AGENTS.md (DeepSeek Harness user-global rule, frontmatter stripped)"
     Write-DshAgentRule -DshHome $DshHome -RuleText $ruleSrcContent
 
-    Write-Host "[16/23] argo\skills\argo-init -> $dshSkillDest (DeepSeek Harness skill)"
+    Write-Host "[16/22] argo\skills\argo-init -> $dshSkillDest (DeepSeek Harness skill)"
     Copy-Tree -Source (Join-Path $argoDir 'skills\argo-init') -Destination $dshSkillDest
 
-    Write-Host "[17/23] argo\rules\<WakeupGuideline> -> $DshHome\plugins\dsh-argo-wakeup\index.js (DeepSeek Harness wakeup plugin)"
+    Write-Host "[17/22] argo\rules\<WakeupGuideline> -> $DshHome\plugins\dsh-argo-wakeup\index.js (DeepSeek Harness wakeup plugin)"
     $wakeupDshPath = New-DshWakeupPlugin -DshHome $DshHome -RuleText $ruleSrcContent
 
-    Write-Host "[18/23] argo-workspace + argo-wakeup rows -> $patchPath (DeepSeek Harness MCP bridge + wakeup plugin)"
+    Write-Host "[18/22] argo-workspace + argo-wakeup rows -> $patchPath (DeepSeek Harness MCP bridge + wakeup plugin)"
     # The generated dsh-argo-workspace bridge connects directly to the argo
     # server (no dsh-mcp-client row), registers every tool as mcp__argo__* and
     # injects the current session's workspace (SessionHeader.cwd) as the
@@ -853,7 +850,7 @@ if ($SkipDsh) {
         Write-DshManagedBlock -Path $patchPath -Block $block -MarkerStart '# BEGIN ArchGraph ARGO deployment' -MarkerEnd '# END ArchGraph ARGO deployment'
     }
 
-    Write-Host "[19/23] argo\agents -> $DshHome\.agent-presets\<id> (DeepSeek Harness agent presets)"
+    Write-Host "[19/22] argo\agents -> $DshHome\.agent-presets\<id> (DeepSeek Harness agent presets)"
     New-DshAgentPresets -DshHome $DshHome -AgentsSrc (Join-Path $argoDir 'agents')
 
     Write-Host "  note: graph-mcp remote ($GraphMcpUrl) is NOT registered for DeepSeek Harness -"
@@ -874,10 +871,10 @@ if ($SkipOpenClaw) {
     $openClawAgentsDest = Join-Path $OpenClawWorkspace 'AGENTS.md'
 
     Write-Host '==> Deploying OpenClaw integration'
-    Write-Host "[20/23] argo\rules\archgraph.instructions.md -> $openClawAgentsDest (OpenClaw workspace AGENTS.md, frontmatter stripped)"
+    Write-Host "[20/22] argo\rules\archgraph.instructions.md -> $openClawAgentsDest (OpenClaw workspace AGENTS.md, frontmatter stripped)"
     Write-OpenClawAgentRule -OpenClawWorkspace $OpenClawWorkspace -RuleText $ruleSrcContent
 
-    Write-Host "[21/23] argo\skills\argo-init -> $openClawSkillDest (OpenClaw managed skill, all agents)"
+    Write-Host "[21/22] argo\skills\argo-init -> $openClawSkillDest (OpenClaw managed skill, all agents)"
     Copy-Tree -Source (Join-Path $argoDir 'skills\argo-init') -Destination $openClawSkillDest
 
     Write-Host '  OpenClaw injects AGENTS.md into Project Context on every session, so the wakeup'
@@ -1046,7 +1043,7 @@ if ($SkipMcp) {
         # location; -OpenClawRepoRoot overrides it (e.g. for tests or when the
         # installer runs from a non-workspace npm-global package dir).
         $openClawRepoRoot = if ($OpenClawRepoRoot) { $OpenClawRepoRoot } else { $repoRoot }
-        Write-Host "[22/23] argo MCP server -> $(Join-Path $OpenClawHome 'openclaw.json') (OpenClaw mcp.servers.argo, env.ARGO_REPO_ROOT pinned)"
+        Write-Host "[22/22] argo MCP server -> $(Join-Path $OpenClawHome 'openclaw.json') (OpenClaw mcp.servers.argo, env.ARGO_REPO_ROOT pinned)"
         Write-OpenClawMcpConfig -OpenClawHome $OpenClawHome -RepoRoot $openClawRepoRoot -ArgoServer $argoServer -GraphMcpServer $openClawGraphMcpServer
     }
 }
@@ -1058,68 +1055,5 @@ if (Test-Path $wakeupPluginPath) {
     Write-Host "argo-wakeup plugin registered -> $OpenCodeConfigPath"
 }
 
-# EA local web service (WP2786): deploy the two service scripts next to the
-# harness scripts (REPO_ROOT = $ArgoRoot keeps the relative layout intact) plus
-# the web/ statics, then start the service in the background. Re-running the
-# installer is idempotent: an occupied port skips the startup.
-$eaServiceSrc = Join-Path $repoRoot 'scripts\ea-web-service.js'
-$eaLayoutStoreSrc = Join-Path $repoRoot 'scripts\ea-layout-store.js'
-$eaWebSrc = Join-Path $repoRoot 'web'
-Write-Host "[23/23] scripts\ea-web-service.js + scripts\ea-layout-store.js + web -> $ArgoRoot (EA local web service)"
-if ((Test-Path $eaServiceSrc) -and (Test-Path $eaLayoutStoreSrc) -and (Test-Path $eaWebSrc)) {
-    Copy-Item -Force -Path $eaServiceSrc -Destination (Join-Path $scriptsDest 'ea-web-service.js')
-    Copy-Item -Force -Path $eaLayoutStoreSrc -Destination (Join-Path $scriptsDest 'ea-layout-store.js')
-    Copy-Tree -Source $eaWebSrc -Destination (Join-Path $ArgoRoot 'web')
-    Write-Host "  service scripts + web statics deployed -> $scriptsDest / $(Join-Path $ArgoRoot 'web')"
-    if ($SkipEaWeb) {
-        Write-Host '  EA web service startup skipped (-SkipEaWeb)'
-    }
-    else {
-        $eaWebRoot = if ($EaWebRoot) { $EaWebRoot } else { $PWD.Path }
-        $eaPortInUse = $false
-        try {
-            $eaProbe = New-Object System.Net.Sockets.TcpClient
-            $eaProbe.Connect('127.0.0.1', $EaWebPort)
-            $eaPortInUse = $true
-            $eaProbe.Close()
-        }
-        catch {
-            $eaPortInUse = $false
-        }
-        if ($eaPortInUse) {
-            Write-Host "  EA web service already listening on 127.0.0.1:$EaWebPort; startup skipped (idempotent re-deploy)"
-        }
-        else {
-            $nodeCmd = Get-Command node -ErrorAction SilentlyContinue
-            if (-not $nodeCmd) {
-                throw 'EA web service startup failed: node not found on PATH'
-            }
-            $eaServiceDest = Join-Path $scriptsDest 'ea-web-service.js'
-            $eaLogOut = Join-Path $ArgoRoot 'ea-web-service.log'
-            $eaLogErr = Join-Path $ArgoRoot 'ea-web-service.err.log'
-            # Start the service through WMI (Win32_Process.Create) instead of
-            # Start-Process: the process is then created by the WMI service and
-            # inherits NONE of this installer's stdio pipe handles. Inherited
-            # pipes would keep spawnSync-based launchers (argo-deploy bin, tests)
-            # blocked until the service exits. cmd.exe is used only to redirect
-            # the service stdout/stderr into log files.
-            $q = [char]34
-            $eaCmdLine = "cmd.exe /S /c $q$q$($nodeCmd.Source)$q $q$eaServiceDest$q --root $q$eaWebRoot$q --port $EaWebPort > $q$eaLogOut$q 2> $q$eaLogErr$q$q"
-            $eaCreate = Invoke-CimMethod -ClassName Win32_Process -MethodName Create -Arguments @{
-                CommandLine      = $eaCmdLine
-                CurrentDirectory = $ArgoRoot
-            }
-            if ($eaCreate.ReturnValue -ne 0) {
-                throw "EA web service startup failed: Win32_Process.Create ReturnValue $($eaCreate.ReturnValue)"
-            }
-            Write-Host "  EA web service started in background (pid $($eaCreate.ProcessId)): http://127.0.0.1:$EaWebPort (root: $eaWebRoot)"
-            Write-Host "  logs: $eaLogOut / $eaLogErr"
-        }
-    }
-}
-else {
-    Write-Host '  EA web service sources not present in this package; step skipped'
-}
-
 Write-Host ''
 Write-Host 'Argo deployment complete.'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archgraph-argo",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Deploy the ArchGraph ARGO toolchain, skills, and rules (schema, scripts, argo-init skill, global rule) with one command.",
   "license": "MIT",
   "bin": {
@@ -16,9 +16,6 @@
     "argo/skills/argo-init",
     "argo/rules",
     "argo/package.json",
-    "scripts/ea-web-service.js",
-    "scripts/ea-layout-store.js",
-    "web",
     "vendor",
     "install-argo.ps1",
     "bin",
@@ -41,7 +38,8 @@
     "neo4j-driver": "^6.2.0"
   },
   "devDependencies": {
-    "@resvg/resvg-js": "^2.6.2"
+    "@resvg/resvg-js": "^2.6.2",
+    "playwright": "1.61.1"
   },
   "scripts": {
     "test": "node --test \"tests/*.test.js\""