archgraph-argo 0.26.2 → 0.27.0

package/argo/scripts/validateSystemArchitecture.js

@@ -1,254 +1,261 @@
-const fs = require('fs');
-const path = require('path');
-
-const {
-  getArgoRoot,
-  getWorkspaceRoot,
-} = require('./argo-paths.js');
-
-const repoRoot = getWorkspaceRoot();
-const graphRelativePath = path.join('design', 'KG', 'SystemArchitecture.json');
-const graphPath = path.join(repoRoot, graphRelativePath);
-const schemaPathCandidates = [
-    path.join(getArgoRoot(), 'schema', 'SystemArchitecture.schema.json'),
-    path.join(repoRoot, '.argo', 'schema', 'SystemArchitecture.schema.json'),
-];
-
-const {
-  validateGraphSemantics,
-  validateArchiMateEndpointMatrix,
-  validateViewElementLimits,
-} = require('./graph-semantics.js');
-
-function main() {
-    const schemaPath = schemaPathCandidates.find(candidate => fs.existsSync(candidate));
-    if (!schemaPath) {
-        fail(`Schema file is missing. Checked: ${schemaPathCandidates.map(candidate => path.relative(repoRoot, candidate)).join(', ')}`);
-    }
-
-    if (!fs.existsSync(graphPath)) {
-        fail('System architecture file is missing at design/KG/SystemArchitecture.json');
-    }
-
-    const schema = parseJson(schemaPath, path.relative(repoRoot, schemaPath));
-    const document = parseJson(graphPath, 'design/KG/SystemArchitecture.json');
-    const errors = [];
-
-    validateAgainstSchema(document, schema, '#', errors, schema);
-    validateGraphSemantics(document, errors);
-    validateArchiMateEndpointMatrix(document, errors);
-    validateViewElementLimits(document, errors);
-
-    if (errors.length > 0) {
-        console.error('SystemArchitecture validation failed:');
-        for (const error of errors) {
-            console.error(`- ${error}`);
-        }
-        process.exit(1);
-    }
-
-    console.log('SystemArchitecture validation passed for: design/KG/SystemArchitecture.json');
-}
-
-function parseJson(filePath, label) {
-    try {
-        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    } catch (error) {
-        fail(`Failed to parse ${label}: ${String(error)}`);
-    }
-}
-
-function validateAgainstSchema(value, schemaNode, pointer, errors, rootSchema) {
-    if (!schemaNode || typeof schemaNode !== 'object') {
-        return;
-    }
-
-    const resolvedSchema = schemaNode.$ref ? resolveRef(schemaNode.$ref, rootSchema, errors, pointer) : schemaNode;
-    if (!resolvedSchema) {
-        return;
-    }
-
-    if (resolvedSchema.const !== undefined && !isDeepStrictEqual(value, resolvedSchema.const)) {
-        errors.push(`${pointer} must equal ${JSON.stringify(resolvedSchema.const)}`);
-        return;
-    }
-
-    if (resolvedSchema.enum && !resolvedSchema.enum.some(option => isDeepStrictEqual(option, value))) {
-        errors.push(`${pointer} must be one of: ${resolvedSchema.enum.map(option => JSON.stringify(option)).join(', ')}`);
-        return;
-    }
-
-    if (resolvedSchema.type !== undefined) {
-        validateType(value, resolvedSchema.type, pointer, errors);
-        if (!typeMatches(value, resolvedSchema.type)) {
-            return;
-        }
-    }
-
-    if (typeof resolvedSchema.minLength === 'number') {
-        if (typeof value !== 'string' || value.length < resolvedSchema.minLength) {
-            errors.push(`${pointer} must be at least ${resolvedSchema.minLength} character(s) long`);
-        }
-    }
-
-    if (typeof resolvedSchema.maxLength === 'number') {
-        if (typeof value !== 'string' || value.length > resolvedSchema.maxLength) {
-            errors.push(`${pointer} must be at most ${resolvedSchema.maxLength} character(s) long`);
-        }
-    }
-
-    if (resolvedSchema.pattern) {
-        const matcher = new RegExp(resolvedSchema.pattern);
-        if (typeof value !== 'string' || !matcher.test(value)) {
-            errors.push(`${pointer} must match pattern ${JSON.stringify(resolvedSchema.pattern)}`);
-        }
-    }
-
-    if (typeof resolvedSchema.minimum === 'number') {
-        if (typeof value !== 'number' || value < resolvedSchema.minimum) {
-            errors.push(`${pointer} must be >= ${resolvedSchema.minimum}`);
-        }
-    }
-
-    if (typeof resolvedSchema.maximum === 'number') {
-        if (typeof value !== 'number' || value > resolvedSchema.maximum) {
-            errors.push(`${pointer} must be <= ${resolvedSchema.maximum}`);
-        }
-    }
-
-    if (typeof resolvedSchema.minItems === 'number') {
-        if (!Array.isArray(value) || value.length < resolvedSchema.minItems) {
-            errors.push(`${pointer} must contain at least ${resolvedSchema.minItems} item(s)`);
-        }
-    }
-
-    if (typeof resolvedSchema.maxItems === 'number') {
-        if (!Array.isArray(value) || value.length > resolvedSchema.maxItems) {
-            errors.push(`${pointer} must contain at most ${resolvedSchema.maxItems} item(s)`);
-        }
-    }
-
-    if (resolvedSchema.uniqueItems === true && Array.isArray(value)) {
-        const seen = new Set();
-        value.forEach((entry, index) => {
-            const serialized = JSON.stringify(entry);
-            if (seen.has(serialized)) {
-                errors.push(`${pointer}[${index}] must be unique within ${pointer}`);
-            } else {
-                seen.add(serialized);
-            }
-        });
-    }
-
-    if (resolvedSchema.type === 'object') {
-        validateObject(value, resolvedSchema, pointer, errors, rootSchema);
-        return;
-    }
-
-    if (resolvedSchema.type === 'array') {
-        validateArray(value, resolvedSchema, pointer, errors, rootSchema);
-    }
-}
-
-function validateObject(value, schemaNode, pointer, errors, rootSchema) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        return;
-    }
-
-    const properties = schemaNode.properties || {};
-    const required = Array.isArray(schemaNode.required) ? schemaNode.required : [];
-
-    for (const key of required) {
-        if (!(key in value)) {
-            errors.push(`${pointer} is missing required property '${key}'`);
-        }
-    }
-
-    if (schemaNode.additionalProperties === false) {
-        for (const key of Object.keys(value)) {
-            if (!(key in properties)) {
-                errors.push(`${pointer} contains unsupported property '${key}'`);
-            }
-        }
-    }
-
-    for (const [key, propertySchema] of Object.entries(properties)) {
-        if (key in value) {
-            validateAgainstSchema(value[key], propertySchema, `${pointer}.${key}`, errors, rootSchema);
-        }
-    }
-}
-
-function validateArray(value, schemaNode, pointer, errors, rootSchema) {
-    if (!Array.isArray(value)) {
-        return;
-    }
-
-    if (schemaNode.items) {
-        value.forEach((entry, index) => {
-            validateAgainstSchema(entry, schemaNode.items, `${pointer}[${index}]`, errors, rootSchema);
-        });
-    }
-}
-
-function validateType(value, expectedType, pointer, errors) {
-    if (!typeMatches(value, expectedType)) {
-        const printableType = Array.isArray(expectedType) ? expectedType.join(' or ') : expectedType;
-        errors.push(`${pointer} must be of type ${printableType}`);
-    }
-}
-
-function typeMatches(value, expectedType) {
-    if (Array.isArray(expectedType)) {
-        return expectedType.some(candidate => typeMatches(value, candidate));
-    }
-
-    switch (expectedType) {
-        case 'object':
-            return value !== null && typeof value === 'object' && !Array.isArray(value);
-        case 'array':
-            return Array.isArray(value);
-        case 'string':
-            return typeof value === 'string';
-        case 'number':
-            return typeof value === 'number' && Number.isFinite(value);
-        case 'integer':
-            return typeof value === 'number' && Number.isInteger(value);
-        case 'boolean':
-            return typeof value === 'boolean';
-        case 'null':
-            return value === null;
-        default:
-            return true;
-    }
-}
-
-function resolveRef(ref, rootSchema, errors, pointer) {
-    if (!ref.startsWith('#/')) {
-        errors.push(`${pointer} uses unsupported $ref '${ref}'`);
-        return undefined;
-    }
-
-    const segments = ref.slice(2).split('/');
-    let current = rootSchema;
-    for (const segment of segments) {
-        if (!current || typeof current !== 'object' || !(segment in current)) {
-            errors.push(`${pointer} references missing schema path '${ref}'`);
-            return undefined;
-        }
-        current = current[segment];
-    }
-
-    return current;
-}
-
-function isDeepStrictEqual(left, right) {
-    return JSON.stringify(left) === JSON.stringify(right);
-}
-
-function fail(message) {
-    console.error(`SystemArchitecture validation failed: ${message}`);
-    process.exit(1);
-}
-
+const fs = require('fs');
+const path = require('path');
+
+const {
+  getWorkspaceRoot,
+} = require('./argo-paths.js');
+
+const {
+  loadSchemaBundleAndOntology,
+} = require('./argob-schema.js');
+
+const repoRoot = getWorkspaceRoot();
+const graphRelativePath = path.join('design', 'KG', 'SystemArchitecture.json');
+const graphPath = path.join(repoRoot, graphRelativePath);
+
+const {
+  validateGraphSemantics,
+  validateArchiMateEndpointMatrix,
+  validateViewElementLimits,
+} = require('./graph-semantics.js');
+
+function main() {
+    let bundle;
+    let ontology;
+    try {
+        ({ bundle, ontology } = loadSchemaBundleAndOntology(repoRoot));
+    } catch (error) {
+        fail(String(error && error.message ? error.message : error));
+    }
+    const schema = bundle.schemaDocument;
+
+    if (!fs.existsSync(graphPath)) {
+        fail('System architecture file is missing at design/KG/SystemArchitecture.json');
+    }
+
+    const document = parseJson(graphPath, 'design/KG/SystemArchitecture.json');
+    const errors = [];
+
+    if (ontology.bundleValidation && ontology.bundleValidation.status === 'failed') {
+        for (const error of ontology.bundleValidation.errors) {
+            errors.push(`schema bundle: ${error}`);
+        }
+    }
+    validateAgainstSchema(document, schema, '#', errors, schema);
+    validateGraphSemantics(document, errors, ontology);
+    validateArchiMateEndpointMatrix(document, errors, { ontology });
+    validateViewElementLimits(document, errors, { ontology });
+
+    if (errors.length > 0) {
+        console.error(`SystemArchitecture validation failed [schema: ${bundle.kind} / ${ontology.language}]:`);
+        for (const error of errors) {
+            console.error(`- ${error}`);
+        }
+        process.exit(1);
+    }
+
+    console.log(`SystemArchitecture validation passed for: design/KG/SystemArchitecture.json [schema: ${bundle.kind} / ${ontology.language}]`);
+}
+
+function parseJson(filePath, label) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch (error) {
+        fail(`Failed to parse ${label}: ${String(error)}`);
+    }
+}
+
+function validateAgainstSchema(value, schemaNode, pointer, errors, rootSchema) {
+    if (!schemaNode || typeof schemaNode !== 'object') {
+        return;
+    }
+
+    const resolvedSchema = schemaNode.$ref ? resolveRef(schemaNode.$ref, rootSchema, errors, pointer) : schemaNode;
+    if (!resolvedSchema) {
+        return;
+    }
+
+    if (resolvedSchema.const !== undefined && !isDeepStrictEqual(value, resolvedSchema.const)) {
+        errors.push(`${pointer} must equal ${JSON.stringify(resolvedSchema.const)}`);
+        return;
+    }
+
+    if (resolvedSchema.enum && !resolvedSchema.enum.some(option => isDeepStrictEqual(option, value))) {
+        errors.push(`${pointer} must be one of: ${resolvedSchema.enum.map(option => JSON.stringify(option)).join(', ')}`);
+        return;
+    }
+
+    if (resolvedSchema.type !== undefined) {
+        validateType(value, resolvedSchema.type, pointer, errors);
+        if (!typeMatches(value, resolvedSchema.type)) {
+            return;
+        }
+    }
+
+    if (typeof resolvedSchema.minLength === 'number') {
+        if (typeof value !== 'string' || value.length < resolvedSchema.minLength) {
+            errors.push(`${pointer} must be at least ${resolvedSchema.minLength} character(s) long`);
+        }
+    }
+
+    if (typeof resolvedSchema.maxLength === 'number') {
+        if (typeof value !== 'string' || value.length > resolvedSchema.maxLength) {
+            errors.push(`${pointer} must be at most ${resolvedSchema.maxLength} character(s) long`);
+        }
+    }
+
+    if (resolvedSchema.pattern) {
+        const matcher = new RegExp(resolvedSchema.pattern);
+        if (typeof value !== 'string' || !matcher.test(value)) {
+            errors.push(`${pointer} must match pattern ${JSON.stringify(resolvedSchema.pattern)}`);
+        }
+    }
+
+    if (typeof resolvedSchema.minimum === 'number') {
+        if (typeof value !== 'number' || value < resolvedSchema.minimum) {
+            errors.push(`${pointer} must be >= ${resolvedSchema.minimum}`);
+        }
+    }
+
+    if (typeof resolvedSchema.maximum === 'number') {
+        if (typeof value !== 'number' || value > resolvedSchema.maximum) {
+            errors.push(`${pointer} must be <= ${resolvedSchema.maximum}`);
+        }
+    }
+
+    if (typeof resolvedSchema.minItems === 'number') {
+        if (!Array.isArray(value) || value.length < resolvedSchema.minItems) {
+            errors.push(`${pointer} must contain at least ${resolvedSchema.minItems} item(s)`);
+        }
+    }
+
+    if (typeof resolvedSchema.maxItems === 'number') {
+        if (!Array.isArray(value) || value.length > resolvedSchema.maxItems) {
+            errors.push(`${pointer} must contain at most ${resolvedSchema.maxItems} item(s)`);
+        }
+    }
+
+    if (resolvedSchema.uniqueItems === true && Array.isArray(value)) {
+        const seen = new Set();
+        value.forEach((entry, index) => {
+            const serialized = JSON.stringify(entry);
+            if (seen.has(serialized)) {
+                errors.push(`${pointer}[${index}] must be unique within ${pointer}`);
+            } else {
+                seen.add(serialized);
+            }
+        });
+    }
+
+    if (resolvedSchema.type === 'object') {
+        validateObject(value, resolvedSchema, pointer, errors, rootSchema);
+        return;
+    }
+
+    if (resolvedSchema.type === 'array') {
+        validateArray(value, resolvedSchema, pointer, errors, rootSchema);
+    }
+}
+
+function validateObject(value, schemaNode, pointer, errors, rootSchema) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return;
+    }
+
+    const properties = schemaNode.properties || {};
+    const required = Array.isArray(schemaNode.required) ? schemaNode.required : [];
+
+    for (const key of required) {
+        if (!(key in value)) {
+            errors.push(`${pointer} is missing required property '${key}'`);
+        }
+    }
+
+    if (schemaNode.additionalProperties === false) {
+        for (const key of Object.keys(value)) {
+            if (!(key in properties)) {
+                errors.push(`${pointer} contains unsupported property '${key}'`);
+            }
+        }
+    }
+
+    for (const [key, propertySchema] of Object.entries(properties)) {
+        if (key in value) {
+            validateAgainstSchema(value[key], propertySchema, `${pointer}.${key}`, errors, rootSchema);
+        }
+    }
+}
+
+function validateArray(value, schemaNode, pointer, errors, rootSchema) {
+    if (!Array.isArray(value)) {
+        return;
+    }
+
+    if (schemaNode.items) {
+        value.forEach((entry, index) => {
+            validateAgainstSchema(entry, schemaNode.items, `${pointer}[${index}]`, errors, rootSchema);
+        });
+    }
+}
+
+function validateType(value, expectedType, pointer, errors) {
+    if (!typeMatches(value, expectedType)) {
+        const printableType = Array.isArray(expectedType) ? expectedType.join(' or ') : expectedType;
+        errors.push(`${pointer} must be of type ${printableType}`);
+    }
+}
+
+function typeMatches(value, expectedType) {
+    if (Array.isArray(expectedType)) {
+        return expectedType.some(candidate => typeMatches(value, candidate));
+    }
+
+    switch (expectedType) {
+        case 'object':
+            return value !== null && typeof value === 'object' && !Array.isArray(value);
+        case 'array':
+            return Array.isArray(value);
+        case 'string':
+            return typeof value === 'string';
+        case 'number':
+            return typeof value === 'number' && Number.isFinite(value);
+        case 'integer':
+            return typeof value === 'number' && Number.isInteger(value);
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'null':
+            return value === null;
+        default:
+            return true;
+    }
+}
+
+function resolveRef(ref, rootSchema, errors, pointer) {
+    if (!ref.startsWith('#/')) {
+        errors.push(`${pointer} uses unsupported $ref '${ref}'`);
+        return undefined;
+    }
+
+    const segments = ref.slice(2).split('/');
+    let current = rootSchema;
+    for (const segment of segments) {
+        if (!current || typeof current !== 'object' || !(segment in current)) {
+            errors.push(`${pointer} references missing schema path '${ref}'`);
+            return undefined;
+        }
+        current = current[segment];
+    }
+
+    return current;
+}
+
+function isDeepStrictEqual(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+
+function fail(message) {
+    console.error(`SystemArchitecture validation failed: ${message}`);
+    process.exit(1);
+}
+
 main();

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

@@ -26,7 +26,7 @@ const SCRIPT_CANDIDATES = {
 const TOOLS = [
   {
     name: 'validateSystemArchitecture',
-    description: 'Validate design/KG/SystemArchitecture.json against .argo/schema/SystemArchitecture.schema.json and Argo graph rules.',
+    description: 'Validate design/KG/SystemArchitecture.json against the workspace-resolved schema bundle (the default ArgoBument schema, or the repository\'s own .argo/schema) and Argo graph rules.',
     inputSchema: {
       type: 'object',
       properties: {},

package/argo/skills/argo-init/SKILL.md

@@ -17,10 +17,12 @@ disable-model-invocation: true
 ## Rules
 
 - **MUST** 调用 ARGO MCP 工具 `initializeWorkspace`（传当前工作区根）执行确定性初始化，并以其返回报告为最终判断依据。
+- **MUST** 报告当前 schema：`initializeWorkspace` 返回的 `schema`（或 harness 的 `schemaBundle`）中的 `kind`（default=内置 ArgoBument / workspace=仓内自定义 / override）、`language`（名称）、`actorElementType`、`dir`、`guide`；输出形如 `schema: default / ArchiMate 3.2`。
 - **MUST** 报告 `mcp` / `systemArchitecture` / `neo4j` / `qeaFullProjection` / `semanticLifecycle` / `subdiagramViews` 与整体 `status`。
 - **MUST** 核验并报告：① `.qea` 投影是否成功（`qeaFullProjection.status`），且投影目标 `qeaFullProjection.qea` 是否为**本仓库自己的 .qea 文件**（解析自 `ARGO_EA_QEA` 或仓库根唯一 `*.qea`）；目标不是本仓库文件或投影失败 → 报告为告警/失败，不得视为 init 成功。
 - **MUST** 核验并报告：Neo4j 投影目标数据库名（`neo4j.database`）是否**与本仓库名一致**（仓库 basename == 数据库名）；不一致 → 报告为告警/失败。
-- **MUST NOT** 读取、打印或复述 `.env` 中的 secret 值；排查时只允许报告 key 是否存在、ACL 主体。
+- **MUST NOT** 因 schema 是自定义的而跳过 `.qea` 投影：投影对任何 schema 都执行；只有确实没有 `.qea` 目标时才允许 `noop`。
+- **MUST NOT** 读取、打印或复述 `.env` 中的 secret 值；排查时只允许报告 key 是否存在。
 - **MUST NOT** 通过 shell 手工执行 WORKSPACE 外的初始化脚本或一组无关命令来替代 `initializeWorkspace`（除非报告显示底层脚本自身失败需要排查）。
 
 ## Workflow
@@ -47,18 +49,13 @@ disable-model-invocation: true
 
 ### 3. Handle Secret File Blockers（仅当报告含 secret 相关失败）
 
-`semanticLifecycle` 或 `systemArchitecture` 失败可能源于 `.env` 安全预检。诊断（不打印 secret 值）：
+`semanticLifecycle` 或 `systemArchitecture` 失败可能源于 `.env` 预检。诊断（不打印 secret 值）：
 
-```powershell
-icacls "$env:USERPROFILE\.argo\.env"
-```
+处理规则（env 文件不做 OS ACL / 权限加固；只保证不被提交）：
 
-处理规则：
-
-- `SECRET_FILE_ACL_UNSAFE`：收紧 Windows ACL，只保留当前用户、Administrators、SYSTEM。
 - `SECRET_FILE_REPARSE_PROHIBITED`：将 `.env` 替换为普通文件（去掉符号链接/重解析点）。
 - `SECRET_FILE_PATH_PROHIBITED`：修正 `ARGO_ENV_FILE` 与安装根 `.env` 不一致的路径。
-- git 跟踪/忽略类错误（`SECRET_FILE_TRACKED` / `SECRET_FILE_NOT_IGNORED`）只在 `.env` 位于 git 仓库内时出现；全局 `.env` 位于仓库外时天然不适用。
+- git 跟踪/忽略类错误（`SECRET_FILE_TRACKED` / `SECRET_FILE_NOT_IGNORED`）：把 `.env` 加入 `.gitignore` 并 `git rm --cached`；全局 `.env` 位于仓库外时天然不适用。
 
 修复后重跑 `initializeWorkspace`。
 
@@ -72,6 +69,7 @@ icacls "$env:USERPROFILE\.argo\.env"
 
 ### 1. Environment Status
 - overall status: ok / failed
+- **解析到的 schema：kind（default/workspace/override）+ language（名称）+ actorElementType + dir/guide**（默认 ArgoBument 还是仓内自定义 schema）
 - whether mcp health passed
 - whether neo4j health passed
 - whether .qea full projection passed

package/argo/skills/ea-human-reconcile/SKILL.md

@@ -15,7 +15,7 @@ Agent 的职责：结合全局分析 draft 中的每条提议、给出建议与
 - [ ] 工作区有 `design/KG/SystemArchitecture.json`（canonical 意图图）——分析全局的依据。
 - [ ] ARGO MCP 可用。关键查询手段：
   - 语义/上下文：`getSystemArchitecture`（带 query.purpose + query.intent）、`getIntentElementContext`（看单个元素/关系/视图的依赖与受影响对象）。
-  - 结构/类型：`queryNeo4jGraph`（只读 Cypher，如 `MATCH (e:Element {graphKey: $graphKey, type:'Business Actor'}) ...`；先 `{schema:true}` 查投影 schema）。
+  - 结构/类型：`queryNeo4jGraph`（只读 Cypher，如 `MATCH (e:Element {graphKey: $graphKey, type:'<element type>'}) ...`）。先 `{schema:true}` 取当前工作区的语言与类型枚举，类型名一律取自该结果，勿硬编码。
   - 校验：`validateSystemArchitecture`；写图：`previewSystemArchitectureMutation` / `applySystemArchitectureMutation`。
 
 ## 原则
@@ -25,6 +25,7 @@ Agent 的职责：结合全局分析 draft 中的每条提议、给出建议与
 - **删除/破坏性提议单独把关**：对 `removeElement` / `removeRelationship` / `removeView`，必须指出 canonical 里谁引用它、删除会级联影响谁，并给出「保留 / 改挂 / 确认删除」的建议，交由人类确认。
 - **新增/更新提议**：核对 type / name / description / attributes 是否与全局命名与类型一致、是否与既有元素/关系重复冲突、应挂在哪个 parent / 视图下。
 - **视图提议**：核对成员是否落在正确层级（parent_element_id 是否合理）、删视图会否使相关 subdiagram_views 悬空。
+- **类型以工作区 schema 为准**：分析前先 `queryNeo4jGraph {schema:true}` 取 `schemaLanguage` 与元素/关系类型枚举；按该枚举判定类型，**勿硬编码 ArchiMate 类型**。
 - **只读取、不泄露**：MUST NOT 读取/复述 `.env` 里的 secret 或推断敏感配置值。
 
 ## 目标

package/dsh-argo-wakeup/index.js

@@ -1,4 +1,4 @@
-// dsh-argo-wakeup - generated by install-argo.ps1 from
+// dsh-argo-wakeup - generated by scripts/gen-dsh-plugins.js from
 // argo/rules/archgraph.instructions.md (single source of truth: the rule file;
 // this file is a deployment artifact, do not edit by hand).
 // DeepSeek Harness equivalent of the OpenCode hook argo/plugins/argo-wakeup.js:
@@ -7,7 +7,7 @@
 // through the argo MCP server before responding.
 export const name = 'dsh-argo-wakeup'
 export const inject = ['systemPrompt']
-const WAKEUP_GATE = "STEP 0 — UNCONDITIONAL STARTUP GATE. This applies to the very first message of every session, including greetings, casual chat, and questions; it may never be skipped, deferred, or treated as optional.\r\n1. Your very FIRST tool call in the session MUST be an ARGO MCP query that lists all `Business Actor`s (getSystemArchitecture with purpose \"audit\" and subject \"Business Actor\"). Identify which `Business Actor` you are. If you are not sure, consult your human partner to confirm your role before doing anything else.\r\n2. Restore your long-term memory: the SUBVIEW hierarchy mounted under that `Business Actor` element — the Views whose `parent_element_id` points to this Actor, plus the elements, relationships, and further nested sub-views inside them (NOT the View that merely includes the Actor in its `included_elements`) — and load it into session memory.\r\n3. If the `agent` attribute of the confirmed Actor differs from your current Agent type, switch to that Agent type, or delegate to an Agent of that type per `\u003cCoperationGuideline\u003e` item 2.\r\n4. If the ARGO MCP is unavailable or errors, state that explicitly to the user before doing anything else. Only after completing this gate may you respond to the user or take any other action."
+const WAKEUP_GATE = "STEP 0 — UNCONDITIONAL STARTUP GATE. Applies to the very first message of every session, greetings and chat included; never skip, defer, or treat it as optional.\n1. Your first tool call MUST resolve the workspace schema and list its Actors: `queryNeo4jGraph` with `{schema:true}` → read `actorElementType` (`null` = no Actor concept, skip Actor identification), then query that element type. Confirm which Actor you are; if unsure, ask your human partner before anything else.\n2. Restore memory: load ONLY the T1 working-memory digest — your T1 summary, the most recent/active memory cards, and any session hooks (unfinished items from the last session). Do NOT bulk-load the T2 long-term memory or T3 archive; recall them on demand via `memory_search`, then read full content with `getIntentElementContext`. T2 is a recall target, not as a bulk context load.\n3. If the Actor's `agent` attribute differs from your type, switch to it or delegate per `<CoperationGuideline>` item 2.\n4. If the ARGO MCP is unavailable or errors, say so before doing anything else."
 export function apply(ctx) {
   ctx.effect(() => ctx.systemPrompt.section({
     name: 'argo:wakeup',

package/dsh-argo-workspace/index.js

@@ -1,5 +1,6 @@
-// dsh-argo-workspace - generated by install-argo.ps1 (single source of truth:
-// the installer; this file is a deployment artifact, do not edit by hand).
+// dsh-argo-workspace - single source of truth for the DSH workspace bridge.
+// install-argo.ps1 copies this file verbatim into ~/.dsh/plugins, so the
+// deployed plugin and this shipped bundle artifact are byte-identical.
 //
 // Direct MCP bridge to the argo server for DeepSeek Harness. Registers every
 // argo tool as mcp__argo__* and injects the current session's workspace