archgraph-argo 0.26.2 → 0.28.0

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

@@ -12,6 +12,18 @@ const {
 const {
   loadRepositoryArgoEnvironment,
 } = require('./repositoryArgoEnvironment.js');
+const {
+  loadSchemaBundleAndOntology,
+} = require('./schema-bundle.js');
+const {
+  externalQueryRequested,
+  queryExternalRead,
+} = require('./external-graph-query.js');
+const {
+  authorizeWorkspaceWrite,
+  isWriteTool,
+  stripTrustedSessionField,
+} = require('./workspace-write-guard.js');
 const {
   getWorkspaceRoot,
   hasStaticWorkspace,
@@ -127,12 +139,12 @@ const TOOLS = [
   },
   {
     name: 'getIntentElementContext',
-    description: 'read-only query that returns an intent subgraph context for one element. Uses ArchiMate semantic dependency traversal with dependencyDepth and dependentDepth, preserving native subgraph elements, relationships, and views.',
+    description: 'read-only query that returns an intent subgraph context for one element. Uses ArchiMate semantic dependency traversal with dependencyDepth and dependentDepth, preserving native subgraph elements, relationships, and views. Output is bounded by maxBytes (default ARGO_CONTEXT_MAX_BYTES or 32000): beyond it non-focus members degrade to identity (id/type/name) with a complete id manifest under truncation, so the host never silently cuts the payload. On a large/hub element leave includeAttributes/includeTestcases off and prefer queryNeo4jGraph to locate ids, then read them narrowly.',
     inputSchema: intentElementContextInputSchema(),
   },
   {
     name: 'previewSystemArchitectureMutation',
-    description: 'Use before apply for complex or risky changes. Performs a dry-run of one or more mutations, runs schema, graph, view, and ArchiMate 3.2 validation, and does not write the graph.',
+    description: 'Use before apply for complex or risky changes. Performs a dry-run of one or more mutations, runs schema, graph, view, and modeling-language validation, and does not write the graph.',
     inputSchema: mutationInputSchema(),
   },
   {
@@ -142,12 +154,18 @@ const TOOLS = [
   },
   {
     name: 'addArchitectureElement',
-    description: 'Use for one element. Creates a new element or adds an existing element to view_ids. view_ids is required so elements never exist outside views.',
+    description: 'Use for one element. Creates a new element or adds an existing element to view_ids. view_ids is required so elements never exist outside views. element.id is OPTIONAL: omit it and the server auto-allocates a unique id (returned in the result); provide it to pin a specific id (must not collide with a different element).',
     inputSchema: {
       type: 'object',
       required: ['element', 'view_ids'],
       properties: {
-        element: { type: 'object' },
+        element: {
+          type: 'object',
+          properties: {
+            id: { type: 'string', description: 'Element id (OPTIONAL). Omit to let the server auto-allocate a unique id (a semantic slug from the name, e.g. "graph-wiki-federation-center", suffixed -002.. if taken). If provided it must not collide with a DIFFERENT element (a same (type,name) match is idempotent reuse).' },
+          },
+          description: 'The element to create/attach. `id` is optional — omit it and the server allocates one (returned in the result).',
+        },
         view_ids: { type: 'array', minItems: 1, items: { type: 'string' } },
         onConflict: { type: 'string', enum: ['reuse', 'allowDuplicate'], description: 'Dedup policy (default reuse). reuse: find-or-create — attach an existing exact (type, name) match; a same-type semantic near-duplicate also blocks creation. allowDuplicate: create anyway (even if a duplicate exists), requires a justification.' },
         justification: { type: 'string', description: 'Required when onConflict is allowDuplicate.' },
@@ -186,7 +204,7 @@ const TOOLS = [
   },
   {
     name: 'addArchitectureRelationship',
-    description: 'Use for one relationship. Creates a new relationship or adds an existing relationship to view_ids. relationship.type is the ArchiMate 3.2 relationship type and is validated against endpoint element types.',
+    description: 'Use for one relationship. Creates a new relationship or adds an existing relationship to view_ids. relationship.type is the ArchiMate 3.2 relationship type and is validated against endpoint element types. relationship.id is OPTIONAL: omit it and the server auto-allocates a unique id (returned in the result).',
     inputSchema: {
       type: 'object',
       required: ['relationship', 'view_ids'],
@@ -230,7 +248,7 @@ const TOOLS = [
   },
   {
     name: 'addArchitectureView',
-    description: 'Use for one view. The graph must have exactly one top-level view named SystemArchitecture; all sub-views must attach to an element with parent_element_id.',
+    description: 'Use for one view. The graph must have exactly one top-level view named SystemArchitecture; all sub-views must attach to an element with parent_element_id. view.view_id is OPTIONAL: omit it and the server auto-allocates a unique view_id (returned in the result).',
     inputSchema: {
       type: 'object',
       required: ['view'],
@@ -330,8 +348,9 @@ function intentElementContextInputSchema() {
       dependentDepth: { type: 'number', description: 'Default: 1. Semantic dependents that rely on the focus element.' },
       associationDepth: { type: 'number', description: 'Default: 1. Association neighbors are expanded at least one layer.' },
       associationNeighborDependencyDepth: { type: 'number', description: 'Default: 0. Optional dependency expansion from association neighbors.' },
-      includeAttributes: { type: 'boolean', description: 'Default: false. Include `attributes` (commit/session/release ledgers) verbatim; omitted by default from this structural read (the focus element always keeps its own).' },
-      includeTestcases: { type: 'boolean', description: 'Default: false. Include member `testcases` verbatim; omitted by default from this structural read.' },
+      includeAttributes: { type: 'boolean', description: 'Default: false. Include `attributes` (commit/session/release ledgers) verbatim; omitted by default from this structural read (the focus element always keeps its own). On a hub element this ledger can dominate the payload.' },
+      includeTestcases: { type: 'boolean', description: 'Default: false. Include member `testcases` verbatim; omitted by default from this structural read. On a hub element this can be large.' },
+      maxBytes: { type: 'number', description: 'Optional output budget in UTF-8 bytes. Default: ARGO_CONTEXT_MAX_BYTES env or 32000. 0 = unlimited. Above the budget, non-focus members degrade to identity (id/type/name) with a complete id manifest under `truncation`; the payload is never silently truncated by the host.' },
     },
     additionalProperties: false,
   };
@@ -397,6 +416,33 @@ function resolveWorkspaceRoot(args) {
 }
 
 async function callTool(name, args = {}, progressToken = null, dependencies = undefined) {
+  // Cross-project WRITE guard (single choke point for every tool): a write tool
+  // may only target this server's HOME workspace, or a host-designated trusted
+  // session workspace when the process was launched by a trusted broker
+  // (ARGO_WORKSPACE_ROOT_TRUSTED=1). A foreign `workspaceRoot` is rejected
+  // fail-closed before any side effect; READ tools stay ungated so cross-project
+  // reading still works. See workspace-write-guard.js.
+  if (isWriteTool(name, args)) {
+    const decision = authorizeWorkspaceWrite({ tool: name, args, homeRoot: getWorkspaceRoot() });
+    if (!decision.allowed) {
+      return toolResult({
+        status: 'failed',
+        error: {
+          category: decision.category,
+          message: decision.message,
+          tool: decision.tool,
+          homeWorkspaceRoot: decision.homeWorkspaceRoot,
+          requestedWorkspaceRoot: decision.requestedWorkspaceRoot,
+          ...(decision.trustedSessionWorkspaceRoot
+            ? { trustedSessionWorkspaceRoot: decision.trustedSessionWorkspaceRoot }
+            : {}),
+        },
+      });
+    }
+  }
+  // The broker-only field is not part of any tool's schema: honor it above, then
+  // drop it before dispatch so schema validation never sees it.
+  args = stripTrustedSessionField(args);
   loadRepositoryArgoEnvironment(resolveWorkspaceRoot(args));
   try {
     const crash = require('./graph-rag/mcpCrashDiagnostics.js');
@@ -405,6 +451,23 @@ async function callTool(name, args = {}, progressToken = null, dependencies = un
   } catch {
     // diagnostics are best-effort; never block a tool call
   }
+  // Cross-project read: a read tool with `projectId` is routed to the federation
+  // center (never silently served from the local graph).
+  if (externalQueryRequested(name, args)) {
+    const result = await queryExternalRead({
+      workspaceRoot: resolveWorkspaceRoot(args),
+      tool: name,
+      args,
+    });
+    // getSystemArchitecture declares an outputSchema, so its result MUST carry
+    // matching structuredContent even on the cross-project path (which bypasses
+    // the systemarchitecture module's own toolResult). A missing
+    // structuredContent makes the MCP client reject the call with -32600.
+    if (name === 'getSystemArchitecture') {
+      return toolResult(result, systemArchitectureMcp.buildGetSystemArchitectureStructuredContent(result));
+    }
+    return toolResult(result);
+  }
   if (name === 'initializeWorkspace') {
     const workspace = await initializeWorkspace(resolveWorkspaceRoot(args));
     // Deterministic argo-init harness report (Neo4j structural sync, semantic
@@ -421,6 +484,10 @@ async function callTool(name, args = {}, progressToken = null, dependencies = un
     return toolResult({
       status: report.status,
       workspaceRoot: workspace.workspaceRoot,
+      // The resolved modeling language for this workspace (default ArchiMate 3.2 vs
+      // the repository's own .argo/schema bundle) so init names the active schema.
+      schema: workspace.schema,
+      schemaBundle: report.schemaBundle,
       targetEaName: workspace.targetEaName,
       createdFiles: workspace.createdFiles,
       updatedFiles: workspace.updatedFiles,
@@ -514,6 +581,22 @@ async function initializeWorkspace(workspaceRoot) {
   const graphTargetPath = path.join(workspaceRoot, ...WORKSPACE_GRAPH_PATH_SEGMENTS);
   const graphRelativePath = normalizeRelativePath(path.relative(workspaceRoot, graphTargetPath));
   if (!fs.existsSync(graphTargetPath)) {
+    // Only the built-in ArchiMate 3.2 default schema auto-provides a graph (the
+    // packaged default). For any custom / replaced schema the graph is the user's
+    // own: never copy the packaged (mismatched) graph — fail closed if missing.
+    let ontology = null;
+    try { ontology = loadSchemaBundleAndOntology(workspaceRoot).ontology; } catch { ontology = null; }
+    const usesPackagedDefaultGraph = !!ontology && ontology.kind === 'default' && ontology.dialect === 'archimate-class-matrix';
+    if (!usesPackagedDefaultGraph) {
+      const label = ontology ? `${ontology.kind} / ${ontology.language}` : 'unknown';
+      const error = new Error(
+        `No default graph for the custom schema (${label}): the workspace has no ${graphRelativePath}. ` +
+        'A custom schema must author its own graph; the packaged default graph is not copied because it would not match the schema. ' +
+        `Add ${graphRelativePath} to the workspace.`,
+      );
+      error.code = 'NO_DEFAULT_GRAPH';
+      throw error;
+    }
     const graphSourcePath = resolveGraphDefaultSourcePath();
     await fs.promises.mkdir(path.dirname(graphTargetPath), { recursive: true });
     await fs.promises.copyFile(graphSourcePath, graphTargetPath);
@@ -553,8 +636,28 @@ async function initializeWorkspace(workspaceRoot) {
   } catch (error) {
     qeaFullProjection = { status: 'failed', error: String(error && error.message ? error.message : error) };
   }
+  // Report which schema this workspace resolves to (default ArchiMate 3.2 vs a
+  // repository's own .argo/schema bundle) so the caller/human can see the active
+  // modeling language right after init.
+  let schema;
+  try {
+    const { bundle, ontology } = loadSchemaBundleAndOntology(workspaceRoot);
+    schema = {
+      kind: bundle.kind,
+      language: ontology.language,
+      dialect: ontology.dialect,
+      dir: bundle.relativeDir,
+      guide: bundle.guidePath ? bundle.guidePath.relativePath : null,
+      actorElementType: ontology.actorElementType,
+      bundleValidation: ontology.bundleValidation ? ontology.bundleValidation.status : null,
+    };
+  } catch (error) {
+    schema = { kind: 'unknown', error: String(error && error.message ? error.message : error) };
+  }
+
   return {
     workspaceRoot,
+    schema,
     qeaFullProjection,
     targetEaName,
     createdFiles,
@@ -621,7 +724,7 @@ function normalizeRelativePath(value) {
   return String(value).replace(/\\/g, '/');
 }
 
-function toolResult(payload) {
+function toolResult(payload, structuredContent = undefined) {
   return {
     content: [
       {
@@ -629,11 +732,20 @@ function toolResult(payload) {
         text: JSON.stringify(payload, null, 2),
       },
     ],
+    ...(structuredContent === undefined ? {} : { structuredContent }),
     isError: payload.status === 'failed',
   };
 }
 
 function canonicalInitErrorResult(error) {
+  // Workspace-bootstrap faults (e.g. a schema with no default graph) are not
+  // semantic-lifecycle secrets and must surface their message to the caller.
+  if (error && error.code === 'NO_DEFAULT_GRAPH') {
+    return toolResult({
+      status: 'failed',
+      error: { category: 'WORKSPACE_INIT_FAILED', code: error.code, message: String(error.message) },
+    });
+  }
   const result = semanticOperatorErrorResult(error);
   if (error.safeSemanticLifecycleMessage !== true) return result;
   const payload = Object.freeze({
@@ -768,6 +880,7 @@ async function handleRequest(request, dependencies = undefined) {
         && params.arguments
         && Object.prototype.hasOwnProperty.call(params.arguments, 'query')
         && params.arguments.query
+        && !externalQueryRequested(params.name, params.arguments)
       ) {
         activeDependencies = {
           semanticOperatorJourney:

package/argo/scripts/ensureArgoHarnessEnvironment.js

@@ -56,6 +56,20 @@ async function runHarnessReport({ checkOnly, workspaceRoot, includeBootstrap })
 
   try {
     report.harnessEnvironment = loadRepositoryArgoEnvironment(workspaceRoot);
+    try {
+      const { bundle, ontology } = require('./schema-bundle.js').loadSchemaBundleAndOntology(workspaceRoot);
+      report.schemaBundle = {
+        kind: bundle.kind,
+        language: ontology.language,
+        dialect: ontology.dialect,
+        dir: bundle.relativeDir,
+        guide: bundle.guidePath ? bundle.guidePath.relativePath : null,
+        actorElementType: ontology.actorElementType,
+        bundleValidation: ontology.bundleValidation ? ontology.bundleValidation.status : null,
+      };
+    } catch (schemaError) {
+      report.schemaBundle = { kind: 'unknown', error: String(schemaError && schemaError.message ? schemaError.message : schemaError) };
+    }
     if (includeBootstrap) {
       report.workspaceBootstrap = await ensureWorkspaceBootstrap({ checkOnly, workspaceRoot });
     }

package/argo/scripts/external-graph-query.js

@@ -0,0 +1,162 @@
+'use strict';
+
+// Cross-project graph query (federation client side).
+//
+// A read tool call may carry an optional `projectId`. Absent => the local
+// workspace (unchanged). Present => the call is routed to the federation center
+// (`POST <centerUrl>/graph/read`), which authorizes and forwards to the mirror
+// engine; the native ARGO result is passed through with a `namespaceKey`. There
+// is NO silent fallback to the local graph.
+//
+// The requester identity is the project's own `projectId`, read from
+// `<workspace>/.argo/federation.json`. If it is missing, external queries fail
+// with an explicit "register first" error — the id is never guessed.
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const EXTERNAL_READ_TOOLS = new Set([
+  'getSystemArchitecture',
+  'getIntentElementContext',
+  'getArchitectureViewContext',
+  'queryNeo4jGraph',
+  'memory_search',
+]);
+
+const FEDERATION_FILE = path.join('.argo', 'federation.json');
+const DEFAULT_CENTER_URL = 'https://argo.derekworkspacev5.com';
+
+function loadFederationIdentity(workspaceRoot) {
+  const file = path.join(workspaceRoot || process.cwd(), FEDERATION_FILE);
+  if (!fs.existsSync(file)) {
+    return null;
+  }
+  try {
+    const identity = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return identity && typeof identity === 'object' ? identity : null;
+  } catch {
+    return null;
+  }
+}
+
+function isExternalQuery(args) {
+  return Boolean(args) && typeof args.projectId === 'string' && args.projectId.trim() !== '';
+}
+
+// A tool call is external iff it is one of the readable tools AND carries projectId.
+function externalQueryRequested(toolName, args) {
+  return EXTERNAL_READ_TOOLS.has(toolName) && isExternalQuery(args);
+}
+
+function forwardedArgs(args) {
+  const out = { ...(args || {}) };
+  // projectId is the router parameter; workspaceRoot/architecturePath are local-only.
+  delete out.projectId;
+  delete out.workspaceRoot;
+  delete out.architecturePath;
+  return out;
+}
+
+/**
+ * Route an external read. Returns the native ARGO result (with an added
+ * `namespaceKey`) on success, or `{ status:'failed', error:{...} }` — never the
+ * local result.
+ *
+ * @param {object} options
+ * @param {string} options.workspaceRoot
+ * @param {string} options.tool
+ * @param {object} options.args
+ * @param {Function} [options.fetchImpl] - injectable fetch (tests)
+ */
+async function queryExternalRead({ workspaceRoot, tool, args, fetchImpl }) {
+  const fetchFn = fetchImpl || globalThis.fetch;
+  if (typeof fetchFn !== 'function') {
+    return { status: 'failed', error: { category: 'EXTERNAL_QUERY_UNREACHABLE', message: 'global fetch is unavailable in this runtime' } };
+  }
+
+  const identity = loadFederationIdentity(workspaceRoot);
+  if (!identity || typeof identity.projectId !== 'string' || identity.projectId.trim() === '') {
+    return {
+      status: 'failed',
+      error: {
+        category: 'EXTERNAL_QUERY_NOT_REGISTERED',
+        message: `No federation identity at ${FEDERATION_FILE}. Register this project with the federation center first (registry_register) and write its projectId to ${FEDERATION_FILE}.`,
+      },
+    };
+  }
+
+  if (!EXTERNAL_READ_TOOLS.has(tool)) {
+    return {
+      status: 'failed',
+      error: { category: 'EXTERNAL_QUERY_TOOL_NOT_ALLOWED', message: `tool '${tool}' is not externally readable`, allowed: [...EXTERNAL_READ_TOOLS] },
+    };
+  }
+
+  const centerUrl = String(identity.centerUrl || DEFAULT_CENTER_URL).replace(/\/+$/, '');
+  const url = `${centerUrl}/graph/read`;
+  const body = {
+    requester: identity.projectId,
+    projectId: args.projectId,
+    tool,
+    args: forwardedArgs(args),
+  };
+
+  let response;
+  try {
+    response = await fetchFn(url, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+  } catch (error) {
+    return {
+      status: 'failed',
+      error: {
+        category: 'EXTERNAL_QUERY_UNREACHABLE',
+        message: `federation center unreachable: ${error && error.message ? error.message : error}`,
+        centerUrl,
+      },
+    };
+  }
+
+  let payload = null;
+  try { payload = await response.json(); } catch { /* leave null */ }
+
+  if (response.status === 200 && payload && payload.status === 'ok') {
+    // The engine returns the ARGO tool result; unwrap a {content:[{text}]}
+    // envelope so callers get the native payload, then stamp the namespaceKey.
+    let result = payload.result;
+    if (result && Array.isArray(result.content) && result.content[0] && typeof result.content[0].text === 'string') {
+      try { result = JSON.parse(result.content[0].text); } catch { /* keep the envelope */ }
+    }
+    if (result && typeof result === 'object') {
+      result = { ...result, namespaceKey: payload.namespaceKey || `proj:${args.projectId}` };
+    }
+    return result;
+  }
+
+  const denied = Boolean(payload && payload.status === 'denied');
+  const reason = (payload && payload.reason)
+    || (response.status === 403 ? 'not_authorized' : `http_${response.status}`);
+  return {
+    status: 'failed',
+    error: {
+      category: denied ? 'EXTERNAL_QUERY_DENIED' : 'EXTERNAL_QUERY_FAILED',
+      reason,
+      httpStatus: response.status,
+      requester: identity.projectId,
+      projectId: args.projectId,
+      namespaceKey: `proj:${args.projectId}`,
+    },
+  };
+}
+
+module.exports = {
+  EXTERNAL_READ_TOOLS,
+  FEDERATION_FILE,
+  DEFAULT_CENTER_URL,
+  loadFederationIdentity,
+  isExternalQuery,
+  externalQueryRequested,
+  queryExternalRead,
+};

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

@@ -611,19 +611,6 @@ function assertProtectedSecretFile(expectedFilePath, adapters) {
   ) {
     throw safeError('SECRET_FILE_GIT_STATE_UNSAFE');
   }
-  const acl = adapters.acl && adapters.acl.inspect();
-  if (!acl || acl.status !== 0 || !acl.identity || typeof acl.stdout !== 'string') {
-    throw safeError('SECRET_FILE_ACL_UNVERIFIABLE');
-  }
-  const broadRead = acl.stdout
-    .split(/\r?\n/)
-    .some(line => /^(Everyone|BUILTIN\\Users|Authenticated Users):.*\((?:R|RX|F|M)\)/i.test(line.trim()));
-  const identityRead = acl.stdout
-    .split(/\r?\n/)
-    .some(line => line.trim().startsWith(`${acl.identity}:`) && /\((?:R|RX|F|M)\)/i.test(line));
-  if (broadRead || !identityRead) {
-    throw safeError('SECRET_FILE_ACL_UNSAFE');
-  }
 }
 
 function requireApprovedProfile(values) {

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

@@ -86,6 +86,8 @@ const LEGACY_KEYS = Object.freeze(['ARGO_NEO4J_URI', 'ARGO_NEO4J_USERNAME', 'ARG
 const HOST_ONLY_ENV_KEYS = Object.freeze([
   'ARGO_ENV_FILE',
   'ARGO_REPO_ROOT',
+  'ARGO_SCHEMA_DIR',
+  'ARGO_ACTOR_ELEMENT_TYPE',
   'ARGO_EA_QEA',
   'ARGO_WORKSPACE_ROOTS',
   'ARGO_SERVER_PATH',
@@ -97,6 +99,11 @@ const HOST_ONLY_ENV_KEYS = Object.freeze([
   'ARGO_MCP_SEMANTIC_DEDUP',
   'ARGO_MCP_SEMANTIC_DEDUP_THRESHOLD',
   'ARGO_SEMANTIC_DEDUP_THRESHOLD',
+  'ARGO_WORKSPACE_WRITE_GUARD',
+  'ARGO_WORKSPACE_ROOT_TRUSTED',
+  'ARGO_COST_PROFILER',
+  'ARGO_COST_TRACE_MAX_BYTES',
+  'ARGO_CONTEXT_MAX_BYTES',
 ]);
 const PROHIBITED_RUNTIME_FIELD_KEYS = Object.freeze(['neo4jUri', 'embeddingCredential']);
 const SECRET_KEYS = new Set(['ARGO_NEO4J_DATABASE_PASSWORD', 'QWEN_KEY', 'ARGO_RERANK_API_KEY', EMBEDDING_API_KEY_KEY]);
@@ -451,76 +458,18 @@ function preflightFile({ canonicalFilePath, configuredFilePath, filesystem, adap
 
   let ignored;
   let tracked;
-  let aclEvidence;
   if (adapters.systemMetadata) {
     const insideRepository = adapters.systemMetadata.isSecretFileInsideGitRepository().status === 0;
     ignored = insideRepository ? adapters.systemMetadata.isSecretFileIgnored() : true;
     tracked = insideRepository ? adapters.systemMetadata.isSecretFileTracked() : false;
-    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);
-    aclEvidence = adapters.acl.inspect(configuredFilePath);
   }
+  // Only the "never committed" guarantee is enforced. OS-level ACL / file-mode
+  // hardening is intentionally NOT required (it caused frequent false failures).
   if (tracked) throw safeError('SECRET_FILE_TRACKED');
   if (!ignored) throw safeError('SECRET_FILE_NOT_IGNORED');
-  if (process.platform === 'win32') {
-    validateAcl(aclEvidence);
-  } else {
-    validatePosixSecretFileAcl(configuredFilePath, filesystem);
-  }
-}
-
-function validateAcl(result) {
-  if (!result || result.status !== 0 || typeof result.stdout !== 'string' || !result.identity) {
-    throw safeError('SECRET_FILE_ACL_UNVERIFIABLE');
-  }
-  const permissions = parseAcl(result.stdout);
-  const current = permissions.get(String(result.identity).toLowerCase());
-  if (!current || !current.allow || current.deny) throw safeError('SECRET_FILE_ACL_UNSAFE');
-  for (const broad of ['everyone', 'builtin\\users', 'authenticated users', 'nt authority\\authenticated users']) {
-    const permission = permissions.get(broad);
-    if (permission && permission.allow && !permission.deny) throw safeError('SECRET_FILE_ACL_UNSAFE');
-  }
-}
-
-function parseAcl(output) {
-  const result = new Map();
-  for (const line of output.split(/\r?\n/)) {
-    const normalizedLine = line.trim().replace(/^[A-Za-z]:\\.*?\.env\s+/, '');
-    const match = normalizedLine.match(/^(.+?):((?:\([^)]*\))+)\s*$/);
-    if (!match) continue;
-    const tokens = [...match[2].matchAll(/\(([^)]*)\)/g)].map(item => item[1].toUpperCase());
-    if (!tokens.some(token => /^(?:F|M|R|RX)$/.test(token))) continue;
-    const key = match[1].trim().toLowerCase();
-    const entry = result.get(key) || { allow: false, deny: false };
-    if (tokens.includes('DENY')) entry.deny = true;
-    else entry.allow = true;
-    result.set(key, entry);
-  }
-  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) {
@@ -612,7 +561,6 @@ function safeError(category) {
 module.exports = {
   resolveApprovedLiveConfiguration,
   withApprovedLiveConfigurationTestComposition,
-  posixModeIsSecretSafe,
   buildProfileConfiguration,
   APPROVED_EMBEDDING_VALUES: APPROVED,
   // The authoritative set of keys an approved `.env` file may carry. The