arkgate 2.2.0 → 2.3.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to ArkGate (`arkgate`; formerly `ark-runtime-kernel`) are documented here.
 
+## 2.3.0 — 2026-07-08
+
+### Added — P0 complete (mechanical-safe depth + release-trust)
+
+- **Third `mechanical-safe` remediation:** pure-type **file** relocate when the whole source
+  file is type-surface only (`sourcePureTypeModule` + type-only edge) —
+  `remediationKind: pure-type-file-relocate`.
+- Keeps 2.2.0 classes: type-only import move; static import of pure-type target modules.
+- **Deferred:** verbatim infra relocation of value modules (cannot prove behavior-preserving).
+- **Release-trust:** `verify-release-tag` defaults to **fail-closed** on unsigned tags;
+  override only via `ARK_ALLOW_UNSIGNED_RELEASE_TAG=true` (publish workflow sets this
+  explicitly until GPG signing is wired). Unit tests cover policy + real script path.
+- Corpus: pure-type file, pure-type target, side-effect type file, require/dynamic, value
+  import, forbidden global, cycles.
+
 ## 2.2.0 — 2026-07-08
 
 ### Added — co-pilot P0 depth (mechanical-safe expansion)

package/bin/ark-check.mjs

@@ -4327,6 +4327,8 @@ function buildRemediationPlan(root, activeViolations, governedPercent = null, to
       ...(v.target ? { target: v.target } : {}),
       ...(v.typeOnly ? { typeOnly: true } : {}),
       ...(v.targetTypeOnlyExports ? { targetTypeOnlyExports: true } : {}),
+      ...(v.sourcePureTypeModule ? { sourcePureTypeModule: true } : {}),
+      ...(verdict.remediationKind ? { remediationKind: verdict.remediationKind } : {}),
     };
   });
   // Order: auto-applicable first (quick, safe wins), then human decisions, then deferred.
@@ -4935,6 +4937,9 @@ async function main() {
         const staticEdge = edge.kind === 'import' || edge.kind === 'export';
         const targetTypeOnlyExports =
           staticEdge && Boolean(targetCached?.exportsOnlyTypes) && !edge.typeOnly;
+        // Importer is itself a pure type-surface file (no runtime body) — enables
+        // pure-type-file-relocate classification when the edge is type-only.
+        const sourcePureTypeModule = Boolean(entry.exportsOnlyTypes);
         violations.push({
           ruleId: 'LAYER_IMPORT_VIOLATION',
           file: relFile,
@@ -4944,6 +4949,7 @@ async function main() {
           target: relTarget,
           ...(edge.typeOnly ? { typeOnly: true } : {}),
           ...(targetTypeOnlyExports ? { targetTypeOnlyExports: true } : {}),
+          ...(sourcePureTypeModule ? { sourcePureTypeModule: true } : {}),
           ...(edge.kind ? { edgeKind: edge.kind } : {}),
           message: rule.message ?? `${sourceLayer} must not ${edge.kind} ${targetLayer}.`,
         });

package/bin/ark-shared.mjs

@@ -542,20 +542,33 @@ export function looksLikeIntent(value) {
  *
  * Deliberately biased toward 'judgment': a false 'mechanical-safe' that auto-lands a bad edit
  * is the failure mode that sinks trust. Only statically-provable type-surface fixes earn 'auto':
- *   (1) import/export already marked type-only
- *   (2) value-syntax import of a module that *only* exports types (convert to import type)
+ *   (1) whole source file is pure type-surface + type-only edge → relocate the file
+ *   (2) import/export already marked type-only → move/re-export the type
+ *   (3) static value-syntax import of a pure type-only *target* module → import type
  * Pure function of one violation object so CLI, MCP, and apply-loop classify identically.
- * Returns { class, confidence, rationale }.
+ * Returns { class, confidence, rationale, remediationKind? }.
  */
 export const REMEDIATION_CLASSES = ['mechanical-safe', 'judgment', 'deferred'];
 
 export function classifyRemediation(violation) {
   const ruleId = violation?.ruleId;
   if (ruleId === 'LAYER_IMPORT_VIOLATION') {
+    // Pure type-only *source file* with a type-only edge: relocating the whole file is
+    // behavior-preserving (no runtime body). Distinct from a single import-type move.
+    if (violation.typeOnly && violation.sourcePureTypeModule) {
+      return {
+        class: 'mechanical-safe',
+        confidence: 0.88,
+        remediationKind: 'pure-type-file-relocate',
+        rationale:
+          'Whole source file is type-only surface (no runtime statements) with a type-only cross-layer edge: relocate the file to the owning layer (or extract the type there). Behavior-preserving; gate verifies.',
+      };
+    }
     if (violation.typeOnly) {
       return {
         class: 'mechanical-safe',
         confidence: 0.9,
+        remediationKind: 'type-only-import-move',
         rationale:
           'Type-only import (erased at runtime): move the type to the layer that owns it and re-export for back-compat. Behavior-preserving, and the gate verifies it.',
       };
@@ -576,6 +589,7 @@ export function classifyRemediation(violation) {
       return {
         class: 'mechanical-safe',
         confidence: 0.85,
+        remediationKind: 'import-type-from-pure-type-module',
         rationale:
           'Static import targets a pure type-only module: convert to `import type` (erased at runtime) and place the type in a shared/owning layer. No runtime coupling; gate verifies.',
       };

package/dist/index.cjs

@@ -80,7 +80,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/version.ts
-var version = "2.2.0";
+var version = "2.3.0";
 
 // src/kernel/intent/IntentRegistry.ts
 var IntentRegistry = class {