arkgate 2.2.0 → 2.4.0

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.',
       };
@@ -616,6 +630,59 @@ export function classifyRemediation(violation) {
   };
 }
 
+/**
+ * Normalize a required/imported TypeScript module for ark-check's host.
+ * TS 5/6 expose `sys` on the root export. Early TS 7 / some ESM interop shapes
+ * may nest under `.default` or omit `sys` — those are unusable for resolve/scan
+ * and must fall through to a JS-API-compatible TypeScript (Ark's own or 5/6).
+ *
+ * @param {unknown} mod
+ * @returns {object | null} usable typescript namespace, or null
+ */
+export function usableTypescript(mod) {
+  if (!mod || typeof mod !== 'object') return null;
+  // Prefer root; if root has no sys but default does (CJS/ESM interop), use default.
+  const candidates = [mod];
+  if (mod.default && typeof mod.default === 'object') candidates.push(mod.default);
+  for (const ts of candidates) {
+    if (
+      ts &&
+      typeof ts === 'object' &&
+      ts.sys &&
+      typeof ts.sys.fileExists === 'function' &&
+      typeof ts.createSourceFile === 'function' &&
+      typeof ts.resolveModuleName === 'function'
+    ) {
+      return ts;
+    }
+  }
+  return null;
+}
+
+/**
+ * Human-readable reason a typescript package module is unusable for the gate.
+ * @param {unknown} mod
+ */
+export function typescriptUsabilityHint(mod) {
+  if (!mod) return 'module is null/undefined';
+  const ts = mod.default && mod.sys == null ? mod.default : mod;
+  if (!ts || typeof ts !== 'object') return 'not an object export';
+  // TS 7.0.x main export is only { version, versionMajorMinor }; classic JS host is not there.
+  if (
+    typeof ts.version === 'string' &&
+    !ts.sys &&
+    typeof ts.createSourceFile !== 'function' &&
+    typeof ts.resolveModuleName !== 'function'
+  ) {
+    return `version-only export (${ts.version}) — TypeScript 7 main entry no longer ships the classic JS host (sys/AST/resolve); gate falls back to a JS-API TypeScript`;
+  }
+  if (!ts.sys) return 'missing ts.sys (common with early TypeScript 7 native builds without a full JS host)';
+  if (typeof ts.sys.fileExists !== 'function') return 'ts.sys.fileExists is not a function';
+  if (typeof ts.createSourceFile !== 'function') return 'missing createSourceFile (AST API)';
+  if (typeof ts.resolveModuleName !== 'function') return 'missing resolveModuleName';
+  return 'unknown shape incompatibility';
+}
+
 /** The three package managers Ark emits commands for. */
 const LOCKFILES = { pnpm: 'pnpm-lock.yaml', yarn: 'yarn.lock', npm: 'package-lock.json' };
 

package/bin/ark.mjs

@@ -123,11 +123,12 @@ async function upgrade(args) {
   let status = runArkCheck(['--root', root, '--install-agent-gates'], { cwd: root });
   if (status !== 0) return status;
 
-  // Codex loads slash-command prompts from ~/.codex/prompts, not the repo — refresh those too
-  // when a Codex home exists, so nothing is left stale. Non-fatal: a permission error there
-  // (e.g. a sandbox) shouldn't fail the whole upgrade.
-  if (fs.existsSync(path.join(os.homedir(), '.codex'))) {
-    console.log('\n     Refreshing Codex home prompts (~/.codex)…');
+  // Codex loads slash-command prompts from $CODEX_HOME/prompts, not the repo — refresh those
+  // when a Codex home exists. --force rewrites temp/upgrade MCP roots to this project + arkgate-mcp.
+  // Non-fatal: a permission error (e.g. sandbox) shouldn't fail the whole upgrade.
+  const codexHomeBase = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+  if (fs.existsSync(codexHomeBase)) {
+    console.log(`\n     Refreshing Codex home (${codexHomeBase})…`);
     runArkCheck(
       ['--root', root, '--install-agent-gates', '--skills-only', '--codex-home', '--force'],
       { cwd: root }
@@ -279,6 +280,10 @@ async function init(args) {
     if (archetype) {
       console.log(`Shape: ${archetype}. Plan: ${arkCommand(root, 'ark-check', '--recommend')}`);
     }
+    console.log(
+      `Freeze day-one architecture snapshot: ${arkCommand(root, 'ark-check', '--report ark-report.html')} (writes .ark/reports/origin.* once).`
+    );
+    console.log(`Adoption health: ${arkCommand(root, 'ark-check', '--doctor')}`);
     return 0;
   } finally {
     rl?.close();
@@ -433,7 +438,17 @@ async function start(args) {
     }
     console.log(`  • Re-run the plan anytime:   ${arkCommand(root, 'ark-check', '--plan')}`);
     console.log(`  • Full project check:        ${arkCommand(root, 'ark-check', '--root . --config ark.config.json --strict-config')}`);
+    console.log(`  • Adoption health:           ${arkCommand(root, 'ark-check', '--doctor')}`);
     console.log(`  • Update Ark later:          ${arkCommand(root, 'ark', 'upgrade')}`);
+    if (fs.existsSync(path.join(root, '.ark-baseline.json'))) {
+      console.log(
+        '  • Baseline file present — keep empty for ratchet-from-clean, or freeze debt with --update-baseline.'
+      );
+    } else {
+      console.log(
+        '  • No baseline yet (fine on clean trees). Adopting dirty code? freeze with --update-baseline.'
+      );
+    }
 
     // 6) First architecture report — freezes an origin snapshot under .ark/reports/
     // so later --report runs can show evolution. Idempotent: origin is written only once.

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.4.0";
 
 // src/kernel/intent/IntentRegistry.ts
 var IntentRegistry = class {