archgraph-argo 0.10.30 → 0.10.32

package/argo/rules/archgraph.instructions.md

@@ -20,6 +20,8 @@ The following are non-negotiable red lines (MUST) for this Agent and must never
 4. Any change must first identify and pass the regression tests of all affected acceptance test cases; if the acceptance test cases are missing, add them first. Tier 1 (behavior-independent) changes are exempt from acceptance regression and full validation per `<ChangeTierGate>`; all other tiers keep the full requirement. See `<AcceptanceTestFirst>` and `<ChangeTierGate>`.
 5. Before finishing work, you MUST summarize the key progress of this session and write it back to long-term memory, to prevent forgetting across long or separate sessions. See `<SessionMemorySummarization>` and `<MemoryTriggerTiming>`.
 6. Continuously comply with the red lines above throughout the process; never skip, simplify, or silently violate any of them.
+7. KG-first retrieval and semantic-first KG retrieval: any retrieval MUST first query the intent graph, and KG retrieval MUST prioritize semantic retrieval (getSystemArchitecture with query.purpose + query.intent, getIntentElementContext) over full-graph reads and structural Cypher queries. See `<QueryPriorityGuideline>`.
+8. Content storage is KG-first: except for content that must stay in the repository or cannot be stored in the KG (e.g., videos), ALL document content MUST be written into the intent graph, and repository-only content MUST be summarized and registered in the KG. See `<ContentStoragePolicy>`.
 </CoreRules>
 
 <Ontology>
@@ -29,11 +31,27 @@ Your cognitive architecture is composed of ArchiMate 3.2 elements and their exte
 </Ontology>
 
 <ExplorationGuideline>
+0. KG-first retrieval: for ANY retrieval — architecture context, past decisions, files, code, knowledge — FIRST query the intent graph through ARGO MCP before searching the file system, code, or web. See `<QueryPriorityGuideline>`.
 1. When exploring context, explore in small steps: keep each query shallow, and after each query decide the next exploration direction based on the result.
 2. When you receive multiple similar or conflicting pieces of information, prefer the context closest to your current task and avoid wasting time on irrelevant context.
 3. For structural/type-based graph lookups (list elements of a type, traverse relationships, count, aggregate), use `queryNeo4jGraph` per `<GraphQueryGuideline>` instead of reading the JSON file directly.
 </ExplorationGuideline>
 
+<QueryPriorityGuideline>
+1. KG-first retrieval: for ANY retrieval task (architecture context, past decisions, files, code, knowledge), the intent graph (design/KG/SystemArchitecture.json via ARGO MCP) is the FIRST hop. Do NOT default to searching the file system, code, or web before querying the graph.
+2. Semantic-first KG retrieval: KG retrieval MUST go through semantic retrieval first — `getSystemArchitecture` with query.purpose + query.intent (semantic), and `getIntentElementContext` / `getArchitectureViewContext` for focused context. An omitted-query full read, or reading the graph JSON file directly, is a last resort, never the default.
+3. `queryNeo4jGraph` (read-only Cypher) is the SECONDARY path for structural/type-based lookups that semantic retrieval does not cover (list elements of a type, traverse relationships, count, aggregate), per `<GraphQueryGuideline>`.
+4. Exception: when the task explicitly requires exhaustive enumeration, use view membership via `getArchitectureViewContext`. Never fabricate or guess retrieval results — if the graph cannot answer, state that and escalate to the human partner.
+5. Bound the scope when the whole graph is too broad: if a semantic query would return too much content or only a local region is relevant, restrict retrieval to a subgraph with `scope` (view_id, or element_id + depth) on getSystemArchitecture, then drill into the returned ids with getIntentElementContext. Prefer a scoped read over an unbounded whole-graph read.
+</QueryPriorityGuideline>
+
+<ContentStoragePolicy>
+1. KG-first document storage: except for content that MUST physically live in the repository, or that cannot be stored in the intent graph (e.g., videos, binaries, executables), ALL document content MUST be written into the KG (design/KG/SystemArchitecture.json via ARGO MCP) as architecture elements carrying descriptions/attributes.
+2. Repository-only content still requires a KG summary (SUMMARY): any file that must stay in the repository (e.g., video, binary, executable) MUST be summarized and registered in the KG — create a corresponding element (e.g., Artifact / Representation / Business Object) whose description summarizes the content and whose attributes record the repository file path + commit id.
+3. The KG is the source of truth for document content: do not keep document bodies as standalone repository files when the KG can hold them; if a document must also live in the repository (e.g., a rendered/exported artifact), the KG element remains authoritative.
+4. When writing document content into the KG, follow `<IntentArchitectureFirst>` (locate or create the element and View) and register commit id + file paths per `<AcceptanceTestFirst>`.
+</ContentStoragePolicy>
+
 <IntentArchitectureFirst>
 1. Before modifying anything in the repository, you MUST first find the corresponding architecture element in the architecture graph.
 2. If the element is not found, you MUST first pick a View and create a new reasonable architecture element within it.
@@ -56,17 +74,17 @@ When you are about to build an element, first look up the skills and resources n
 
 <ChangeTierGate>
 Every repository change MUST be classified into exactly one tier BEFORE implementation; the tier is declared explicitly. Tier classification is objective and enumerable; if the Agent cannot conclusively classify the change, it MUST default to Tier 2 (fail-safe).
-1. Tier 1 — 行为无关（behavior-independent）: qualifies ONLY if ALL of the following hold:
+1. Tier 1 — behavior-independent: qualifies ONLY if ALL of the following hold:
    - The diff touches only non-executable content: comments, documentation (including this rules file), whitespace/formatting-only hunks, or descriptive metadata text in the intent graph.
    - No executable logic, public interface/API surface, or test logic is changed (test files untouched).
    - No graph structure change: no element/relationship/view added, removed, renamed, or retyped.
-   - Skipped ceremony（跳过验收回归与全量校验）: acceptance test identification and regression, and full validateSystemArchitecture, are skipped (unless the graph was touched). Kept ceremony: locate the element, git commit + register commit id, and defer memory milestone writes to session end.
-2. Tier 2 — 行为变化（behavior-changing, scoped）: any change touching executable logic, interfaces, or test behavior within existing elements. Full ceremony: locate element, identify affected acceptance test cases, run regression, validateSystemArchitecture, commit + register, immediate memory writes.
-3. Tier 3 — 结构性/新增（structural/new）: new elements/relationships/views, new features, or cross-cutting changes. Full Tier 2 ceremony plus preview/apply mutation for any graph change.
+   - Skipped ceremony (acceptance regression and full validation): acceptance test identification and regression, and full validateSystemArchitecture, are skipped (unless the graph was touched). Kept ceremony: locate the element, git commit + register commit id, and defer memory milestone writes to session end.
+2. Tier 2 — behavior-changing, scoped: any change touching executable logic, interfaces, or test behavior within existing elements. Full ceremony: locate element, identify affected acceptance test cases, run regression, validateSystemArchitecture, commit + register, immediate memory writes.
+3. Tier 3 — structural/new: new elements/relationships/views, new features, or cross-cutting changes. Full Tier 2 ceremony plus preview/apply mutation for any graph change.
 4. Safety net (MUST, non-negotiable):
-   - Declared tier is verified at commit time: the actual git diff file list is checked against the Tier 1 allowlist; if any disallowed file/hunk appears, the change automatically 升为 Tier 2 and MUST complete the acceptance regression and validation before finishing. Tier 1 is revocable, not merely declared.
-   - KG 触线规则: any diff touching design/KG/SystemArchitecture.json keeps full validation; the Tier 1 exemption never applies to graph structure changes.
-   - 零歧义默认升档（fail-safe）: any uncertain classification MUST be treated as Tier 2, never Tier 1.
+   - Declared tier is verified at commit time: the actual git diff file list is checked against the Tier 1 allowlist; if any disallowed file/hunk appears, the change is automatically escalated to Tier 2 and MUST complete the acceptance regression and validation before finishing. Tier 1 is revocable, not merely declared.
+   - KG touch rule: any diff touching design/KG/SystemArchitecture.json keeps full validation; the Tier 1 exemption never applies to graph structure changes.
+   - Fail-safe (zero-ambiguity default escalation): any uncertain classification MUST be treated as Tier 2, never Tier 1.
 </ChangeTierGate>
 
 <CoperationGuideline>
@@ -78,8 +96,8 @@ Every repository change MUST be classified into exactly one tier BEFORE implemen
 </CoperationGuideline>
 
 <CapabilityDelegationGuideline>
-1. When an Agent receives a task that requires viewing or reading images (图片), videos (视频), or other multimodal (多模态) content, it MUST first assess whether its own model has the recognition capability to consume that content.
-2. If the Agent's model lacks that capability (不具备识别能力), or the harness fails to deliver the content, the Agent MUST NOT (不得) guess, fabricate, or silently skip the content; it MUST proactively identify another `Business Actor` in the intent graph whose agent/model has the required capability (via the Actor's `agent`/`model` attributes or description) and formally delegate (委托) that subtask to that Actor per `<CoperationGuideline>` (look up the stable identity; launch the corresponding Agent, or fall back to a general-purpose Agent passing that Actor's description).
+1. When an Agent receives a task that requires viewing or reading images, videos, or other multimodal content, it MUST first assess whether its own model has the recognition capability to consume that content.
+2. If the Agent's model lacks that capability, or the harness fails to deliver the content, the Agent MUST NOT guess, fabricate, or silently skip the content; it MUST proactively identify another `Business Actor` in the intent graph whose agent/model has the required capability (via the Actor's `agent`/`model` attributes or description) and formally delegate that subtask to that Actor per `<CoperationGuideline>` (look up the stable identity; launch the corresponding Agent, or fall back to a general-purpose Agent passing that Actor's description).
 3. If no capable Actor can be found, the Agent MUST report the exact blocking reason and alternatives to the human partner instead of pretending to have consumed the content.
 4. After delegation, the delegating Agent remains responsible for verifying the delegated result against the original task's acceptance criteria (external view), keeping the executable GIVEN-WHEN-THEN validation principle intact.
 </CapabilityDelegationGuideline>
@@ -103,7 +121,7 @@ The above immediate records also follow the conciseness and de-duplication requi
 
 <ToolsGuideline>
 You MUST read/write the intent architecture through the tools provided by the ARGO MCP server; direct modification of the intent architecture source file is forbidden:
-1. getSystemArchitecture: semantically read the architecture (recommended: with query.purpose + query.intent, rather than a full read).
+1. getSystemArchitecture: semantically read the architecture — MUST supply query.purpose + query.intent (semantic retrieval per <QueryPriorityGuideline>); an omitted-query full read is a last resort, not the default.
 2. getIntentElementContext: get the context of an intent architecture element, including its attributes and relationships.
 3. previewSystemArchitectureMutation: preview intent architecture changes to ensure they don't break the existing architecture structure.
 4. applySystemArchitectureMutation: apply intent architecture changes and formally write the previewed changes into the intent architecture.
@@ -126,7 +144,7 @@ For structural/type-based graph lookups, use the read-only Neo4j Cypher interfac
 2. Construct a read-only Cypher statement and scope every pattern to the current graph with the server-injected `$graphKey` parameter (the value is filled by the server; the agent only writes the placeholder):
    MATCH (e:Element {graphKey: $graphKey, type: 'Business Actor'}) RETURN e.id, e.name ORDER BY e.name
 3. Never submit write clauses (CREATE, MERGE, DELETE, SET, REMOVE, DROP, LOAD CSV, FOREACH, IN TRANSACTIONS); the interface rejects them to protect the canonical JSON single source of truth.
-4. Use it for structural queries: list elements of a type, traverse ARCHIMATE_RELATES edges, count and aggregate. For semantic/context reading (subgraph context, dependency traversal, view membership), keep using getSystemArchitecture (semantic query), getIntentElementContext, and getArchitectureViewContext.
+4. Use it as the SECONDARY path for structural/type-based lookups that semantic retrieval does not cover: list elements of a type, traverse ARCHIMATE_RELATES edges, count and aggregate. Semantic-first KG retrieval — semantic/context reading (getSystemArchitecture with query.purpose + query.intent, getIntentElementContext, getArchitectureViewContext) is the PRIORITY path per <QueryPriorityGuideline>.
 5. The query is read-only; never attempt to mutate the graph through Cypher.
 </GraphQueryGuideline>
 

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

@@ -66,6 +66,7 @@ const SYSTEM_ARCHITECTURE_TOOL_NAMES = new Set([
   'removeArchitectureView',
   'generateArchitectureDiffPlantuml',
   'queryNeo4jGraph',
+  'memory_search',
 ]);
 
 const TOOLS = [
@@ -157,6 +158,16 @@ const TOOLS = [
             },
             intent: { type: 'string', description: 'Natural-language intent for semantic retrieval, for example "summarize business features for high-risk audit".' },
             subject: { type: 'string', description: 'Required for audit; optional anchor/focus id for other semantic purposes.' },
+            scope: {
+              type: 'object',
+              description: 'Optional subgraph scope to bound semantic retrieval and limit the returned content to a local region. Provide view_id to search within one view membership, or element_id (+ depth) to search within an element subtree.',
+              properties: {
+                view_id: { type: 'string', description: 'Restrict retrieval to the members of this view.' },
+                element_id: { type: 'string', description: 'Restrict retrieval to this element and its mounted sub-view subtree.' },
+                depth: { type: 'number', description: 'Default: 2. Subtree depth for element scope.' },
+              },
+              additionalProperties: false,
+            },
           },
           additionalProperties: true,
         },

package/argo/scripts/graph-rag/defaultSemanticRetrieval.js

@@ -36,7 +36,7 @@ const APPROVED_PROFILE = Object.freeze({
   model: 'qwen3.7-text-embedding',
   provider: 'alibaba-cloud-model-studio-openai-compatible-cn-beijing',
   version: 'qualification-2026-07-25',
-  dimensions: 1024,
+  dimensions: 1536,
 });
 const CHANNELS = Object.freeze([
   Object.freeze({
@@ -68,12 +68,49 @@ const VECTOR_QUERY_CYPHER = [
   'RETURN properties(node) AS record, score',
   'ORDER BY score DESC',
 ].join('\n');
+const VECTOR_QUERY_CYPHER_SCOPED = [
+  'CALL db.index.vector.queryNodes($indexName, $topK, $vector)',
+  'YIELD node, score',
+  'WHERE node.channel = $channel AND node.canonicalIdentity IN $canonicalIdentities',
+  'RETURN properties(node) AS record, score',
+  'ORDER BY score DESC',
+].join('\n');
 const READINESS_QUERY_CYPHER = [
   'MATCH (readiness:ArgoProductionSemanticReadiness {identity: $identity})',
   'RETURN properties(readiness) AS readiness',
 ].join('\n');
 const INITIAL_WINDOW_SIZE = 2;
+// Purpose-aware, env-configurable similarity thresholds + bounded top-K recall.
+// Audit keeps the strict threshold (precision); memory-retrieval purposes use a
+// looser threshold so relevant-but-paraphrased memory is recalled, while results
+// are bounded to ARGO_SEMANTIC_TOP_K so noise stays bounded. Thresholds are
+// overridable per channel via ARGO_SEMANTIC_{MEMORY|AUDIT}_THRESHOLD_<CHANNEL>.
+const AUDIT_PURPOSES = new Set(['audit']);
+const DEFAULT_MEMORY_THRESHOLD = 0.55;
+const DEFAULT_AUDIT_THRESHOLD = 0.8;
+const DEFAULT_TOP_K = 8;
 const SELECTED_VIEW_ID = 'semprod-wp2-default-retrieval-readiness';
+
+function envNumber(key, fallback) {
+  const value = Number(process.env[key]);
+  return Number.isFinite(value) ? value : fallback;
+}
+function memoryThresholdFor(channel) {
+  return envNumber(
+    `ARGO_SEMANTIC_MEMORY_THRESHOLD_${channel.channel.toUpperCase()}`,
+    envNumber('ARGO_SEMANTIC_MEMORY_THRESHOLD', DEFAULT_MEMORY_THRESHOLD),
+  );
+}
+function auditThresholdFor(channel) {
+  return envNumber(
+    `ARGO_SEMANTIC_AUDIT_THRESHOLD_${channel.channel.toUpperCase()}`,
+    envNumber('ARGO_SEMANTIC_AUDIT_THRESHOLD', DEFAULT_AUDIT_THRESHOLD),
+  );
+}
+function resolveTopK() {
+  const k = envNumber('ARGO_SEMANTIC_TOP_K', DEFAULT_TOP_K);
+  return Number.isInteger(k) && k > 0 ? k : DEFAULT_TOP_K;
+}
 const testCompositionStorage = new AsyncLocalStorage();
 
 function createDefaultSemanticRetrieval(dependencies = {}) {
@@ -159,22 +196,31 @@ async function executeWpP2Retrieval({
   readiness,
   configurationEvidence,
 }) {
+  const { canonicalIdentities, ...completeRequest } = request;
   const provider = createLiveEmbeddingProviderClient({
     configuration: configurationEvidence.configuration,
     transport: composition.transport,
   });
   const vector = await provider.embed(request.intent);
   requireQualifiedVector(vector);
+  const purpose = request && typeof request.purpose === 'string' ? request.purpose : '';
+  const strict = AUDIT_PURPOSES.has(purpose);
+  const topK = resolveTopK();
   const seedsByType = {};
   for (const channel of CHANNELS) {
     seedsByType[channel.key] = await exhaustChannel({
       channel,
       neo4jDriver: composition.neo4jDriver,
       vector,
+      threshold: strict ? auditThresholdFor(channel) : memoryThresholdFor(channel),
+      maxSeeds: topK,
+      ...(Array.isArray(canonicalIdentities) && canonicalIdentities.length > 0
+        ? { canonicalIdentities }
+        : {}),
     });
   }
   return completeSemanticResult({
-    request,
+    request: completeRequest,
     canonicalGraph,
     readiness,
     seedsByType,
@@ -609,11 +655,21 @@ function publicReadinessOutcome(alignment) {
   };
 }
 
-async function exhaustChannel({ channel, neo4jDriver, vector }) {
+async function exhaustChannel({
+  channel,
+  neo4jDriver,
+  vector,
+  canonicalIdentities,
+  threshold,
+  maxSeeds,
+}) {
+  const scoped = Array.isArray(canonicalIdentities) && canonicalIdentities.length > 0;
   const accepted = [];
   const seen = new Set();
+  const effectiveThreshold = typeof threshold === 'number' ? threshold : channel.threshold;
+  const effectiveMax = Number.isInteger(maxSeeds) && maxSeeds > 0 ? maxSeeds : Number.POSITIVE_INFINITY;
   let offset = 0;
-  while (true) {
+  while (accepted.length < effectiveMax) {
     const parameters = Object.freeze({
       indexName: channel.indexName,
       channel: channel.channel,
@@ -621,19 +677,21 @@ async function exhaustChannel({ channel, neo4jDriver, vector }) {
       windowSize: INITIAL_WINDOW_SIZE,
       topK: offset + INITIAL_WINDOW_SIZE,
       vector,
+      ...(scoped ? { canonicalIdentities } : {}),
     });
     const result = await neo4jDriver.execute(Object.freeze({
       kind: 'semantic-vector-window-query',
       channel: channel.channel,
       indexName: channel.indexName,
-      cypher: VECTOR_QUERY_CYPHER,
+      cypher: scoped ? VECTOR_QUERY_CYPHER_SCOPED : VECTOR_QUERY_CYPHER,
       parameters,
     }));
     const records = Array.isArray(result && result.records) ? result.records : [];
     const newlyVisible = records.slice(offset);
     for (const raw of newlyVisible) {
+      if (accepted.length >= effectiveMax) break;
       const record = normalizeVectorRecord(raw, channel);
-      if (record && record.score >= channel.threshold && !seen.has(record.id)) {
+      if (record && record.score >= effectiveThreshold && !seen.has(record.id)) {
         seen.add(record.id);
         accepted.push(Object.freeze(record));
       }
@@ -966,4 +1024,8 @@ function safeError(category) {
 module.exports = {
   createDefaultSemanticRetrieval,
   withDefaultSemanticRetrievalTestComposition,
+  memoryThresholdFor,
+  auditThresholdFor,
+  resolveTopK,
+  AUDIT_PURPOSES,
 };

package/argo/scripts/graph-rag/liveEmbeddingIndexGate.js

@@ -46,7 +46,7 @@ function createLiveEmbeddingIndexGate(dependencies = {}) {
       requireInput(input);
       const vector = await client.embed(input.input);
       if (
-        vector.length !== 1024
+        vector.length !== 1536
         || vector.some(value => typeof value !== 'number' || !Number.isFinite(value))
       ) {
         throw safeError('LIVE_PROVIDER_RESPONSE_INVALID');
@@ -79,7 +79,7 @@ function requireApprovedConfiguration(configuration, qualification) {
     || qualification.model !== configuration.embeddingModel
     || qualification.version !== configuration.embeddingModelVersion
     || qualification.dimensions !== configuration.embeddingDimensions
-    || qualification.dimensions !== 1024
+    || qualification.dimensions !== 1536
   ) {
     throw safeError('LIVE_PROVIDER_INDEX_WRITE_PROHIBITED');
   }

package/argo/scripts/graph-rag/liveEmbeddingNeo4jBoundary.js

@@ -64,11 +64,11 @@ async function createApprovedNeo4jBoundary({ configuration, neo4j, logger }) {
       return result.records.map(record => normalizeNeo4jValue(record.get('evidence')));
     },
     async queryVectorEvidence(runId, vector, canonicalIdentities) {
-      if (!Array.isArray(vector) || vector.length !== 1024 || !Array.isArray(canonicalIdentities)) {
+      if (!Array.isArray(vector) || vector.length !== 1536 || !Array.isArray(canonicalIdentities)) {
         throw safeError('LIVE_PROVIDER_OPERATION_FAILED');
       }
       await query(
-        'CREATE VECTOR INDEX argo_live_embedding_vector IF NOT EXISTS FOR (e:ArgoLiveEmbeddingEvidence) ON (e.vector) OPTIONS { indexConfig: { `vector.dimensions`: 1024, `vector.similarity_function`: "cosine" } }',
+        'CREATE VECTOR INDEX argo_live_embedding_vector IF NOT EXISTS FOR (e:ArgoLiveEmbeddingEvidence) ON (e.vector) OPTIONS { indexConfig: { `vector.dimensions`: 1536, `vector.similarity_function`: "cosine" } }',
         {},
       );
       const result = await query(

package/argo/scripts/graph-rag/liveEmbeddingProviderConfig.js

@@ -21,6 +21,20 @@ const CONFIG_KEYS = Object.freeze([
 const OPTIONAL_CONFIG_KEYS = Object.freeze([
   'ARGO_NEO4J_DATABASE',
 ]);
+// Semantic-retrieval tuning knobs (purpose-aware thresholds + bounded top-K).
+// They are read by defaultSemanticRetrieval from process.env and whitelisted here
+// so an approved env file may carry them without tripping SECRET_FILE_UNKNOWN_KEY.
+const RETRIEVAL_TUNING_KEYS = Object.freeze([
+  'ARGO_SEMANTIC_MEMORY_THRESHOLD',
+  'ARGO_SEMANTIC_MEMORY_THRESHOLD_ELEMENT',
+  'ARGO_SEMANTIC_MEMORY_THRESHOLD_RELATIONSHIP',
+  'ARGO_SEMANTIC_MEMORY_THRESHOLD_VIEW',
+  'ARGO_SEMANTIC_AUDIT_THRESHOLD',
+  'ARGO_SEMANTIC_AUDIT_THRESHOLD_ELEMENT',
+  'ARGO_SEMANTIC_AUDIT_THRESHOLD_RELATIONSHIP',
+  'ARGO_SEMANTIC_AUDIT_THRESHOLD_VIEW',
+  'ARGO_SEMANTIC_TOP_K',
+]);
 const OPT_IN_KEYS = Object.freeze({
   ARGO_LIVE_PROVIDER_E2E: 'LIVE_PROVIDER_E2E_OPT_IN_REQUIRED',
   ARGO_W31_LIVE_MUTATION_VECTOR_E2E: 'W31_MUTATION_VECTOR_E2E_OPT_IN_REQUIRED',
@@ -28,6 +42,7 @@ const OPT_IN_KEYS = Object.freeze({
 const READABLE_KEYS = Object.freeze([
   ...CONFIG_KEYS,
   ...OPTIONAL_CONFIG_KEYS,
+  ...RETRIEVAL_TUNING_KEYS,
   ...Object.keys(OPT_IN_KEYS),
 ]);
 const LEGACY_KEYS = Object.freeze(['ARGO_NEO4J_URI', 'ARGO_NEO4J_USERNAME', 'ARGO_NEO4J_PASSWORD']);
@@ -38,7 +53,7 @@ const APPROVED = Object.freeze({
   ARGO_EMBEDDING_MODEL: 'qwen3.7-text-embedding',
   ARGO_EMBEDDING_PROVIDER: 'alibaba-cloud-model-studio-openai-compatible-cn-beijing',
   ARGO_EMBEDDING_MODEL_VERSION: 'qualification-2026-07-25',
-  ARGO_EMBEDDING_DIMENSIONS: '1024',
+  ARGO_EMBEDDING_DIMENSIONS: '1536',
 });
 const issuedAdapters = new WeakSet();
 const issuedTraces = new WeakSet();
@@ -167,7 +182,7 @@ async function resolveTrusted({
     embeddingModel: normalized.ARGO_EMBEDDING_MODEL,
     embeddingProvider: normalized.ARGO_EMBEDDING_PROVIDER,
     embeddingModelVersion: normalized.ARGO_EMBEDDING_MODEL_VERSION,
-    embeddingDimensions: 1024,
+    embeddingDimensions: 1536,
     neo4jDatabaseUrl: normalized.ARGO_NEO4J_DATABASE_URL,
     neo4jDatabaseUsername: normalized.ARGO_NEO4J_DATABASE_USERNAME,
     neo4jDatabasePassword: normalized.ARGO_NEO4J_DATABASE_PASSWORD,
@@ -342,13 +357,15 @@ function preflightFile({ canonicalFilePath, configuredFilePath, filesystem, adap
     const insideRepository = adapters.systemMetadata.isSecretFileInsideGitRepository().status === 0;
     ignored = insideRepository ? adapters.systemMetadata.isSecretFileIgnored() : true;
     tracked = insideRepository ? adapters.systemMetadata.isSecretFileTracked() : false;
-    const identityResult = adapters.systemMetadata.readCurrentIdentity();
-    const aclResult = adapters.systemMetadata.readSecretFileAcl();
-    aclEvidence = {
-      status: aclResult.status,
-      stdout: aclResult.stdout,
-      identity: identityResult.status === 0 ? identityResult.stdout.trim() : '',
-    };
+    if (process.platform === 'win32') {
+      const identityResult = adapters.systemMetadata.readCurrentIdentity();
+      const aclResult = adapters.systemMetadata.readSecretFileAcl();
+      aclEvidence = {
+        status: aclResult.status,
+        stdout: aclResult.stdout,
+        identity: identityResult.status === 0 ? identityResult.stdout.trim() : '',
+      };
+    }
   } else {
     ignored = adapters.git.isIgnored(configuredFilePath);
     tracked = adapters.git.isTracked(configuredFilePath);
@@ -356,7 +373,11 @@ function preflightFile({ canonicalFilePath, configuredFilePath, filesystem, adap
   }
   if (tracked) throw safeError('SECRET_FILE_TRACKED');
   if (!ignored) throw safeError('SECRET_FILE_NOT_IGNORED');
-  validateAcl(aclEvidence);
+  if (process.platform === 'win32') {
+    validateAcl(aclEvidence);
+  } else {
+    validatePosixSecretFileAcl(configuredFilePath, filesystem);
+  }
 }
 
 function validateAcl(result) {
@@ -389,6 +410,20 @@ function parseAcl(output) {
   return result;
 }
 
+function posixModeIsSecretSafe(mode) {
+  return (mode & 0o077) === 0 && (mode & 0o600) === 0o600;
+}
+
+function validatePosixSecretFileAcl(configuredFilePath, filesystem) {
+  const stat = filesystem.lstatSync(configuredFilePath);
+  if (!posixModeIsSecretSafe(stat.mode)) {
+    throw safeError('SECRET_FILE_ACL_UNSAFE');
+  }
+  if (typeof process.getuid === 'function' && stat.uid !== process.getuid()) {
+    throw safeError('SECRET_FILE_ACL_UNSAFE');
+  }
+}
+
 function productionSourceBehavior(repositoryRoot) {
   return Object.freeze({
     expectedFilePath: getArgoEnvPath(),
@@ -478,4 +513,5 @@ function safeError(category) {
 module.exports = {
   resolveApprovedLiveConfiguration,
   withApprovedLiveConfigurationTestComposition,
+  posixModeIsSecretSafe,
 };

package/argo/scripts/graph-rag/mutationEmbeddingVectorLifecycle.js

@@ -1143,7 +1143,7 @@ function createSyntheticVectorTransport() {
           return {
             data: [
               {
-                embedding: Array.from({ length: 1024 }, (_, index) => index / 2048),
+                embedding: Array.from({ length: 1536 }, (_, index) => index / 2048),
               },
             ],
           };

package/argo/scripts/graph-rag/semantic-persistence/productionSemanticBackfill.js

@@ -15,6 +15,8 @@ function createProductionSemanticBackfill(dependencies = {}) {
   requireBoundary(dependencies.structuralProjection, 'requireComplete', 'structuralProjection');
   requireBoundary(dependencies.embeddingProvider, 'embedBatch', 'embeddingProvider');
   requireBoundary(dependencies.projectionStore, 'upsertRecords', 'projectionStore');
+  requireBoundary(dependencies.projectionStore, 'readRecords', 'projectionStore');
+  requireBoundary(dependencies.projectionStore, 'deleteTombstones', 'projectionStore');
   requireBoundary(dependencies.checkpointStore, 'readCheckpoint', 'checkpointStore');
   requireBoundary(dependencies.checkpointStore, 'writeCheckpoint', 'checkpointStore');
   const batchSize = dependencies.batchSize;
@@ -55,6 +57,11 @@ function createProductionSemanticBackfill(dependencies = {}) {
           checkpointStore: dependencies.checkpointStore,
         });
       }
+      const reconciled = await reconcileRemovals({
+        snapshot,
+        canonicalVersion,
+        projectionStore: dependencies.projectionStore,
+      });
       const aligned = CHANNELS.every(channel => (
         channels[channel].status === 'complete'
         && channels[channel].canonicalVersion === canonicalVersion
@@ -64,6 +71,7 @@ function createProductionSemanticBackfill(dependencies = {}) {
         canonicalVersion,
         alignmentState: aligned ? 'Aligned' : 'Updating',
         channels: Object.freeze(channels),
+        reconciled,
       });
     },
   });
@@ -204,6 +212,39 @@ function mergeFailures(existing, current) {
   return [...merged.values()];
 }
 
+// Full-reconciliation removal pass: after all channels are upserted, delete any
+// persisted semantic record whose canonical identity no longer exists in the
+// local JSON snapshot. This guarantees argo-init rebuilds a semantic projection
+// that is exactly consistent with the canonical graph (no stale vectors).
+async function reconcileRemovals({ snapshot, canonicalVersion, projectionStore }) {
+  const currentByChannel = new Map();
+  for (const channel of CHANNELS) {
+    const source = CHANNEL_SOURCES[channel];
+    const identities = new Set(
+      (snapshot[source.property] || []).map(record => `${channel}:${source.identity(record)}`),
+    );
+    currentByChannel.set(channel, identities);
+  }
+  const stored = await projectionStore.readRecords();
+  const allStored = Array.isArray(stored) ? stored : [];
+  const stale = allStored.filter(record => {
+    const identities = currentByChannel.get(record.channel);
+    return identities && !identities.has(record.canonicalIdentity);
+  });
+  const tombstones = stale.map(record => Object.freeze({
+    canonicalIdentity: record.canonicalIdentity,
+    channel: record.channel,
+    canonicalVersion: record.canonicalVersion || canonicalVersion,
+  }));
+  if (tombstones.length > 0) {
+    await projectionStore.deleteTombstones(tombstones);
+  }
+  return Object.freeze({
+    scanned: allStored.length,
+    tombstoned: tombstones.length,
+  });
+}
+
 function requireBoundary(boundary, method, name) {
   if (!boundary || typeof boundary[method] !== 'function') {
     throw new TypeError(`${name}.${method} is required`);

package/argo/scripts/graph-rag/semantic-persistence/productionSemanticNeo4jAdapter.js

@@ -90,14 +90,31 @@ function createProductionSemanticNeo4jAdapter(dependencies = {}) {
   });
 }
 
+const EMBEDDING_DIMENSIONS = 1536;
+
 async function ensureVectorIndexes(session) {
   for (const definition of Object.values(CHANNEL_INDEXES)) {
+    // CREATE ... IF NOT EXISTS cannot change an existing index's dimensions, so
+    // when the approved embedding dimension changes (e.g. 1024 -> 1536) drop the
+    // stale index first and recreate it at the approved dimension.
+    const existing = await executeRead(
+      session,
+      'SHOW INDEXES YIELD name, type, options WHERE type = \'VECTOR\' AND name = $name RETURN name, options',
+      { name: definition.indexName },
+    );
+    if (existing.records.length > 0) {
+      const options = existing.records[0].get('options');
+      const dim = options && options.indexConfig && options.indexConfig['vector.dimensions'];
+      if (dim !== EMBEDDING_DIMENSIONS) {
+        await executeWrite(session, `DROP INDEX ${definition.indexName} IF EXISTS`, {});
+      }
+    }
     await executeWrite(
       session,
       [
         `CREATE VECTOR INDEX ${definition.indexName} IF NOT EXISTS`,
         `FOR (semantic:${definition.label}) ON (semantic.vector)`,
-        'OPTIONS { indexConfig: { `vector.dimensions`: 1024, `vector.similarity_function`: "cosine" } }',
+        `OPTIONS { indexConfig: { \`vector.dimensions\`: ${EMBEDDING_DIMENSIONS}, \`vector.similarity_function\`: "cosine" } }`,
       ].join('\n'),
       {},
     );

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

@@ -128,7 +128,7 @@ const W31_APPROVED_PROFILE = Object.freeze({
   baseUrl: 'https://llm-clids9mqc5o1mbvb.cn-beijing.maas.aliyuncs.com/compatible-mode/v1',
   model: 'qwen3.7-text-embedding',
   version: 'qualification-2026-07-25',
-  dimensions: 1024,
+  dimensions: 1536,
   source: 'explicit-human-approval',
 });
 
@@ -204,6 +204,16 @@ const TOOLS = [
             },
             intent: { type: 'string', description: 'Natural-language intent for semantic retrieval, for example "summarize business features for high-risk audit".' },
             subject: { type: 'string', description: 'Required for audit; optional anchor/focus id for other semantic purposes.' },
+            scope: {
+              type: 'object',
+              description: 'Optional subgraph scope to bound semantic retrieval and limit the returned content to a local region. Provide view_id to search within one view membership, or element_id (+ depth) to search within an element subtree.',
+              properties: {
+                view_id: { type: 'string', description: 'Restrict retrieval to the members of this view.' },
+                element_id: { type: 'string', description: 'Restrict retrieval to this element and its mounted sub-view subtree.' },
+                depth: { type: 'number', description: 'Default: 2. Subtree depth for element scope.' },
+              },
+              additionalProperties: false,
+            },
           },
           additionalProperties: true,
         },
@@ -396,6 +406,20 @@ const TOOLS = [
       additionalProperties: false,
     },
   },
+  {
+    name: 'memory_search',
+    description: 'Semantic memory search: retrieve the user\'s memory by natural-language query. Runs embedding-based semantic retrieval (memory-retrieval purpose) over the intent graph and returns the top-k relevant memory items (id, name, type, similarity score, and a description excerpt with its full length). Each hit is a lightweight card: to keep the tool result compact, description is truncated to max_desc_len characters (default 800) and the full text length is reported as description_length. To read the full text of a hit, call getIntentElementContext with its id. Agents SHOULD call this tool to look up the user\'s memory before answering a question about the user.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Natural-language query describing the user memory to retrieve.' },
+        top_k: { type: 'integer', description: 'Optional max number of hits to return (default 8).' },
+        max_desc_len: { type: 'integer', description: 'Optional max characters of description to return per hit. Default 800. Use 0 for the full description, or -1 to omit description and return only the length.' },
+        architecturePath: { type: 'string', description: `Default: ${DEFAULT_GRAPH_PATH}` },
+      },
+      additionalProperties: false,
+    },
+  },
 ];
 
 // Every tool accepts an optional per-call `workspaceRoot` (absolute path,
@@ -2178,9 +2202,91 @@ async function callTool(name, args = {}, dependencies = undefined) {
     return queryNeo4jGraphTool(args);
   }
 
+  if (name === 'memory_search') {
+    return memorySearchTool(args, dependencies);
+  }
+
   throw new Error(`Unknown tool: ${name}`);
 }
 
+// memory_search: natural-language semantic memory retrieval. Reuses the
+// memory-retrieval purpose (implementation-design) of the semantic journey
+// (same path as getSystemArchitecture, so readiness/closure behave identically)
+// and reshapes the retrieved elements into a memory-oriented hit list with
+// content + similarity score, so an agent can look up the user's memory in one
+// call.
+async function memorySearchTool(args = {}, dependencies = undefined) {
+  const query = typeof args.query === 'string' ? args.query.trim() : '';
+  if (!query) {
+    return { status: 'failed', error: { category: 'MEMORY_QUERY_REQUIRED', message: 'query is required' } };
+  }
+  const topK = Number.isInteger(args.top_k) && args.top_k > 0 ? args.top_k : 8;
+  // max_desc_len: default 800 (compact excerpt). 0 = full description;
+  // -1 = omit description entirely and return only the length. Keeps the tool
+  // result compact (production memory cards, not full session dumps).
+  let maxDescLen = 800;
+  if (Number.isInteger(args.max_desc_len) && args.max_desc_len !== 800) {
+    maxDescLen = args.max_desc_len;
+  }
+  const context = await loadContext(args);
+  let retrieved;
+  try {
+    const journey = await resolveSemanticOperatorJourney(dependencies);
+    retrieved = await journey.query({ purpose: 'implementation-design', intent: query });
+  } catch (error) {
+    return {
+      status: 'failed',
+      error: {
+        category: error && error.category ? error.category : 'MEMORY_RETRIEVAL_FAILED',
+        message: error && error.message ? error.message : 'Memory retrieval failed',
+      },
+    };
+  }
+  const source = retrieved && (retrieved.result || retrieved.document) || retrieved;
+  const subset = buildCanonicalSemanticDocumentSubset(source, context.document);
+  if (subset.status !== 'passed') {
+    return { status: 'failed', error: subset.error || { category: 'MEMORY_RETRIEVAL_FAILED' } };
+  }
+  const hits = (Array.isArray(subset.document && subset.document.elements) ? subset.document.elements : [])
+    .filter(element => element && typeof element.semanticScore === 'number')
+    .sort((left, right) => right.semanticScore - left.semanticScore)
+    .slice(0, topK)
+    .map(element => Object.freeze(memoryHitCard(element, maxDescLen)));
+  return {
+    status: 'passed',
+    query,
+    max_desc_len: maxDescLen,
+    fullTextHint: 'To read the full text of a hit, call getIntentElementContext with its id (elementId).',
+    hits: Object.freeze(hits),
+  };
+}
+
+// Build one compact memory hit: id/name/type/score + an excerpt of the
+// description bounded by maxDescLen, plus the full text length so the caller
+// knows how much content exists and can decide whether to expand.
+function memoryHitCard(element, maxDescLen) {
+  const description = typeof element.description === 'string' ? element.description : '';
+  const descriptionLength = description.length;
+  let excerpt = '';
+  if (maxDescLen !== -1) {
+    excerpt = maxDescLen === 0 ? description : description.slice(0, maxDescLen);
+  }
+  const card = {
+    id: element.id,
+    name: element.name,
+    type: element.type,
+    score: element.semanticScore,
+    description_length: descriptionLength,
+  };
+  if (maxDescLen !== -1) {
+    card.description = excerpt;
+    if (maxDescLen > 0 && descriptionLength > maxDescLen) {
+      card.truncated = true;
+    }
+  }
+  return card;
+}
+
 async function queryNeo4jGraphTool(args = {}) {
   const architecturePath = args.architecturePath || DEFAULT_GRAPH_PATH;
   const workspaceRoot = resolveWorkspaceRoot(args);
@@ -2291,6 +2397,16 @@ async function executeSemanticSystemArchitectureQuery(args, dependencies) {
       : {}),
   });
   const query = args.query;
+  const scopeResolution = resolveSemanticScope(context.document, query && query.scope);
+  if (scopeResolution.status === 'failed') {
+    return getSystemArchitectureResult(queryError(
+      scopeResolution.error.category,
+      scopeResolution.error.message,
+    ));
+  }
+  const queryForRetrieval = Array.isArray(scopeResolution.identities) && scopeResolution.identities.length > 0
+    ? { ...(query || {}), canonicalIdentities: scopeResolution.identities }
+    : query;
   const contractOptions = semanticContractOptions(args, dependencies);
   const canonicalSubsetContract = isCanonicalSubsetSemanticContract(query, contractOptions);
   if (canonicalSubsetContract) {
@@ -2310,7 +2426,7 @@ async function executeSemanticSystemArchitectureQuery(args, dependencies) {
   }
   let document;
   try {
-    const retrieved = await semanticRetrievalBoundary.retrieve(query);
+    const retrieved = await semanticRetrievalBoundary.retrieve(queryForRetrieval);
     if (canonicalSubsetContract) {
       const subset = buildCanonicalSemanticDocumentSubset(retrieved, context.document);
       if (subset.status === 'failed') {
@@ -2352,6 +2468,14 @@ async function executeSemanticSystemArchitectureQuery(args, dependencies) {
       semanticErrorEvidence,
     ));
   }
+  if (
+    Array.isArray(scopeResolution.identities)
+    && scopeResolution.identities.length > 0
+    && document
+    && typeof document === 'object'
+  ) {
+    document = applySemanticScopeFilter(document, scopeResolution.identities);
+  }
   const semanticPayload = {
     status: 'passed',
     graphPath: context.graphPath.relativePath,
@@ -2381,6 +2505,109 @@ function shouldReturnDebugSemanticResult(query) {
   ).toLowerCase());
 }
 
+function resolveSemanticScope(document, scope) {
+  if (!scope || typeof scope !== 'object') {
+    return { identities: undefined };
+  }
+  const elements = new Set();
+  const relationships = new Set();
+  const views = new Set();
+
+  if (typeof scope.view_id === 'string' && scope.view_id) {
+    const view = (document.views || []).find(item => item && item.view_id === scope.view_id);
+    if (!view) {
+      return {
+        status: 'failed',
+        error: {
+          category: 'SCOPE_VIEW_NOT_FOUND',
+          message: `Scope view '${scope.view_id}' does not exist in the canonical graph`,
+        },
+      };
+    }
+    (view.included_elements || []).forEach(id => elements.add(String(id)));
+    (view.included_relationships || []).forEach(id => relationships.add(String(id)));
+    views.add(String(scope.view_id));
+    return { identities: scopeIdentitiesOf(elements, relationships, views) };
+  }
+
+  if (typeof scope.element_id === 'string' && scope.element_id) {
+    const root = (document.elements || []).find(item => item && item.id === scope.element_id);
+    if (!root) {
+      return {
+        status: 'failed',
+        error: {
+          category: 'SCOPE_ELEMENT_NOT_FOUND',
+          message: `Scope element '${scope.element_id}' does not exist in the canonical graph`,
+        },
+      };
+    }
+    const depth = Number.isInteger(scope.depth) && scope.depth > 0 ? scope.depth : 2;
+    elements.add(String(scope.element_id));
+    const queue = [{ elementId: scope.element_id, level: 0 }];
+    const visited = new Set();
+    while (queue.length > 0) {
+      const { elementId, level } = queue.shift();
+      if (visited.has(elementId)) continue;
+      visited.add(elementId);
+      const element = (document.elements || []).find(item => item && item.id === elementId);
+      const subViews = Array.isArray(element && element.subdiagram_views)
+        ? element.subdiagram_views
+        : [];
+      for (const subView of subViews) {
+        const view = (document.views || []).find(item => item && item.view_id === subView.view_id);
+        if (!view) continue;
+        views.add(String(view.view_id));
+        (view.included_relationships || []).forEach(id => relationships.add(String(id)));
+        for (const childId of (view.included_elements || [])) {
+          elements.add(String(childId));
+          if (level < depth - 1) {
+            queue.push({ elementId: childId, level: level + 1 });
+          }
+        }
+      }
+    }
+    return { identities: scopeIdentitiesOf(elements, relationships, views) };
+  }
+
+  return { identities: undefined };
+}
+
+function scopeIdentitiesOf(elements, relationships, views) {
+  return [...elements, ...relationships, ...views];
+}
+
+function applySemanticScopeFilter(document, identities) {
+  if (!document || typeof document !== 'object' || !Array.isArray(identities)) {
+    return document;
+  }
+  const allowed = new Set(identities.map(id => String(id)));
+  if (
+    Array.isArray(document.elements)
+    || Array.isArray(document.relationships)
+    || Array.isArray(document.views)
+  ) {
+    return Object.freeze({
+      ...document,
+      elements: Object.freeze((document.elements || []).filter(item => item && allowed.has(String(item.id)))),
+      relationships: Object.freeze((document.relationships || []).filter(item => item && allowed.has(String(item.id)))),
+      views: Object.freeze((document.views || []).filter(item => item && allowed.has(String(item.view_id)))),
+    });
+  }
+  if (document.businessObjects) {
+    return Object.freeze({
+      ...document,
+      businessObjects: Object.freeze({
+        elements: Object.freeze((document.businessObjects.elements || []).filter(item => item && allowed.has(String(item.id)))),
+        relationships: Object.freeze((document.businessObjects.relationships || []).filter(item => item && allowed.has(String(item.id)))),
+        views: Object.freeze((document.businessObjects.views || []).filter(item => item && allowed.has(String(item.view_id)))),
+      }),
+      semanticSeeds: Object.freeze((document.semanticSeeds || []).filter(seed => seed && allowed.has(String(seed.objectId)))),
+      hitReasons: Object.freeze((document.hitReasons || []).filter(reason => reason && allowed.has(String(reason.objectId)))),
+    });
+  }
+  return document;
+}
+
 function buildBusinessSemanticSummary(retrieved, query = {}) {
   if (retrieved && retrieved.responseProfile === 'business-summary') return retrieved;
   if (retrieved && retrieved.result && retrieved.result.responseProfile === 'business-summary') return retrieved.result;
@@ -2649,15 +2876,52 @@ function buildCanonicalSemanticDocumentSubset(source, canonicalDocument = undefi
     }
   }
 
+  // Attach the semantic similarity score to each retrieved object so callers can
+  // judge relevance (top-K bounded recall may include borderline neighbours).
+  const semanticScoreById = new Map();
+  const seedsByType = evidence.seedsByType || {};
+  for (const channelSeeds of Object.values(seedsByType)) {
+    for (const seed of Array.isArray(channelSeeds) ? channelSeeds : []) {
+      if (!seed || !seed.id) continue;
+      const numericScore = Number(seed.score);
+      if (!Number.isFinite(numericScore)) continue;
+      const bareId = String(seed.id).replace(/^[^:]*:/, '');
+      if (bareId && (!semanticScoreById.has(bareId) || numericScore > semanticScoreById.get(bareId))) {
+        semanticScoreById.set(bareId, numericScore);
+      }
+    }
+  }
+  // buildCanonicalSemanticDocumentSubset may run a second time over a prior
+  // subset document (which no longer carries seedsByType); carry scores forward
+  // from evidence elements that already expose semanticScore.
+  for (const item of evidenceElements) {
+    if (!item) continue;
+    const numericScore = Number(item.semanticScore);
+    if (!Number.isFinite(numericScore)) continue;
+    const key = String(item.id !== undefined ? item.id : item.view_id);
+    if (key && (!semanticScoreById.has(key) || numericScore > semanticScoreById.get(key))) {
+      semanticScoreById.set(key, numericScore);
+    }
+  }
+  const withSemanticScore = item => {
+    if (!item) return item;
+    const score = item.id !== undefined
+      ? semanticScoreById.get(String(item.id))
+      : semanticScoreById.get(String(item.view_id));
+    return typeof score === 'number' ? Object.freeze({ ...item, semanticScore: score }) : item;
+  };
   const elements = [...elementIds]
     .map(id => canonicalElementById.get(id))
-    .filter(Boolean);
+    .filter(Boolean)
+    .map(withSemanticScore);
   const relationships = [...relationshipIds]
     .map(id => canonicalRelationshipById.get(id))
-    .filter(Boolean);
+    .filter(Boolean)
+    .map(withSemanticScore);
   const views = [...viewIds]
     .map(id => canonicalViewById.get(id))
-    .filter(Boolean);
+    .filter(Boolean)
+    .map(withSemanticScore);
 
   return {
     status: 'passed',
@@ -3348,8 +3612,11 @@ module.exports = {
   compactMutationResponse,
   createDefaultCanonicalSemanticInitComposition,
   createDefaultProductionSemanticOperatorJourney,
+  applySemanticScopeFilter,
   handleRequest,
   loadContext,
   main,
+  memoryHitCard,
+  resolveSemanticScope,
   validateDocument,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "archgraph-argo",
-  "version": "0.10.30",
+  "version": "0.10.32",
   "description": "Deploy the ArchGraph ARGO toolchain, skills, and rules (schema, scripts, argo-init skill, global rule) with one command.",
   "license": "MIT",
   "bin": {