diff --git a/scripts/build.affine b/scripts/build.affine
index bb6c92f..765a95e 100644
--- a/scripts/build.affine
+++ b/scripts/build.affine
@@ -1,11 +1,8 @@
 // SPDX-License-Identifier: MPL-2.0
-// Ported via Harvard Engine mechanical processor
+// Ported via Harvard Engine (Semantic pass)
 
 module build;
 
-// TODO: Complete semantic implementation
-
-/* === ORIGINAL TYPESCRIPT CONTEXT ===
 // SPDX-License-Identifier: MPL-2.0
 // Build script for DoubleTrack Browser extension
 // Uses Deno for file operations
@@ -13,11 +10,11 @@ module build;
 import { copy, ensureDir } from "https://deno.land/std@0.220.1/fs/mod.ts";
 import { join } from "https://deno.land/std@0.220.1/path/mod.ts";
 
-const SRC_DIR = "src";
-const DIST_DIR = "dist";
-const RUST_PKG_DIR = "rust_core/pkg";
+let SRC_DIR = "src";
+let DIST_DIR = "dist";
+let RUST_PKG_DIR = "rust_core/pkg";
 
-async function build() {
+async fn build() {
   console.log("📦 Building DoubleTrack Browser extension...");
 
   // Create dist directory
@@ -31,7 +28,7 @@ async function build() {
   console.log("  ✓ Copied manifest.json");
 
   // Copy HTML files
-  const htmlFiles = [
+  let htmlFiles = [
     { src: "popup/popup.html", dest: "popup.html" },
     { src: "options/options.html", dest: "options.html" },
     { src: "dashboard/dashboard.html", dest: "dashboard.html" },
@@ -46,7 +43,7 @@ async function build() {
   }
 
   // Copy CSS files
-  const cssFiles = [
+  let cssFiles = [
     { src: "popup/popup.css", dest: "popup.css" },
     { src: "options/options.css", dest: "options.css" },
     { src: "dashboard/dashboard.css", dest: "dashboard.css" },
@@ -61,7 +58,7 @@ async function build() {
   }
 
   // Copy compiled ReScript JS files
-  const jsFiles = [
+  let jsFiles = [
     { src: "background/Background.res.js", dest: "background.js" },
     { src: "content/Content.res.js", dest: "content.js" },
     { src: "popup/Popup.res.js", dest: "popup.js" },
@@ -105,4 +102,3 @@ if (import.meta.main) {
   await build();
 }
 
-==================================== */
diff --git a/tests/affine/driver.affine b/tests/affine/driver.affine
index 88b7afc..03c7d3a 100644
--- a/tests/affine/driver.affine
+++ b/tests/affine/driver.affine
@@ -1,11 +1,8 @@
 // SPDX-License-Identifier: MPL-2.0
-// Ported via Harvard Engine mechanical processor
+// Ported via Harvard Engine (Semantic pass)
 
 module driver;
 
-// TODO: Complete semantic implementation
-
-/* === ORIGINAL TYPESCRIPT CONTEXT ===
 // SPDX-License-Identifier: MPL-2.0
 // Copyright (c) 2026 Jonathan D.A. Jewell (hyperpolymath) <j.d.a.jewell@open.ac.uk>
 //
@@ -24,4 +21,3 @@ import { runAll } from "@hyperpolymath/affinescript-deno-test";
 
 await runAll(new URL("./", import.meta.url).pathname);
 
-==================================== */
diff --git a/tests/aspect/security_test.affine b/tests/aspect/security_test.affine
index c929820..b08e4f9 100644
--- a/tests/aspect/security_test.affine
+++ b/tests/aspect/security_test.affine
@@ -1,18 +1,15 @@
 // SPDX-License-Identifier: MPL-2.0
-// Ported via Harvard Engine mechanical processor
+// Ported via Harvard Engine (Semantic pass)
 
 module security_test;
 
-// TODO: Complete semantic implementation
-
-/* === ORIGINAL TYPESCRIPT CONTEXT ===
 // SPDX-License-Identifier: MPL-2.0
 // Security aspect tests for DoubleTrack browser extension
 
 import { assertEquals, assertStringIncludes } from "jsr:@std/assert";
 
 Deno.test("Security: XSS prevention in URL display", () => {
-  const sanitizeUrl = (url: string): string => {
+  let sanitizeUrl = (url: string): string => {
     // In real implementation, this would escape HTML special chars
     return url.replace(/[<>"]/g, (char) => {
       const escapeMap: Record<string, string> = {
@@ -24,15 +21,15 @@ Deno.test("Security: XSS prevention in URL display", () => {
     });
   };
 
-  const maliciousUrl = '<script>alert("xss")</script>';
-  const sanitized = sanitizeUrl(maliciousUrl);
+  let maliciousUrl = '<script>alert("xss")</script>';
+  let sanitized = sanitizeUrl(maliciousUrl);
 
   assertEquals(sanitized.includes("<script>"), false);
   assertEquals(sanitized.includes("&lt;script&gt;"), true);
 });
 
 Deno.test("Security: content isolation", () => {
-  interface IsolatedContent {
+  struct IsolatedContent {
     isSandboxed: boolean;
     allowedOrigins: string[];
   }
@@ -50,7 +47,7 @@ Deno.test("Security: content isolation", () => {
 });
 
 Deno.test("Security: HTTPS enforcement", () => {
-  const isHttpsUrl = (url: string): boolean => {
+  let isHttpsUrl = (url: string): boolean => {
     return url.startsWith("https://");
   };
 
@@ -60,15 +57,15 @@ Deno.test("Security: HTTPS enforcement", () => {
 });
 
 Deno.test("Security: message validation", () => {
-  interface ValidatedMessage {
+  struct ValidatedMessage {
     type: string;
     source: string;
     timestamp: number;
   }
 
-  const validateMessage = (msg: unknown): msg is ValidatedMessage => {
+  let validateMessage = (msg: unknown): msg is ValidatedMessage => {
     if (typeof msg !== "object" || msg === null) return false;
-    const m = msg as Record<string, unknown>;
+    let m = msg as Record<string, unknown>;
     return (
       typeof m.type === "string" &&
       typeof m.source === "string" &&
@@ -76,13 +73,13 @@ Deno.test("Security: message validation", () => {
     );
   };
 
-  const validMsg = {
+  let validMsg = {
     type: "PROFILE_UPDATE",
     source: "background",
     timestamp: Date.now(),
   };
 
-  const invalidMsg = {
+  let invalidMsg = {
     type: "PROFILE_UPDATE",
     source: "background",
     // Missing timestamp
@@ -93,19 +90,19 @@ Deno.test("Security: message validation", () => {
 });
 
 Deno.test("Security: origin verification", () => {
-  const verifyOrigin = (
+  let verifyOrigin = (
     origin: string,
     allowedOrigins: string[]
   ): boolean => {
     try {
-      const url = new URL(origin);
+      let url = new URL(origin);
       return allowedOrigins.includes(url.origin);
     } catch {
       return false;
     }
   };
 
-  const allowed = ["https://example.com", "https://test.com"];
+  let allowed = ["https://example.com", "https://test.com"];
 
   assertEquals(
     verifyOrigin("https://example.com/page", allowed),
@@ -118,7 +115,7 @@ Deno.test("Security: origin verification", () => {
 });
 
 Deno.test("Security: no plain HTTP for sensitive operations", () => {
-  const isSensitiveOperation = (operation: string): boolean => {
+  let isSensitiveOperation = (operation: string): boolean => {
     return [
       "PROFILE_SAVE",
       "PROFILE_LOAD",
@@ -126,7 +123,7 @@ Deno.test("Security: no plain HTTP for sensitive operations", () => {
     ].includes(operation);
   };
 
-  const performSecureRequest = (
+  let performSecureRequest = (
     operation: string,
     protocol: string
   ): boolean => {
@@ -142,8 +139,8 @@ Deno.test("Security: no plain HTTP for sensitive operations", () => {
 });
 
 Deno.test("Security: no sensitive data in logs", () => {
-  const containsSensitiveData = (logMessage: string): boolean => {
-    const sensitivePatterns = [
+  let containsSensitiveData = (logMessage: string): boolean => {
+    let sensitivePatterns = [
       /password/i,
       /token/i,
       /secret/i,
@@ -163,7 +160,7 @@ Deno.test("Security: no sensitive data in logs", () => {
 });
 
 Deno.test("Security: CSP headers enforcement", () => {
-  interface ContentSecurityPolicy {
+  struct ContentSecurityPolicy {
     scriptSrc: string[];
     styleSrc: string[];
     imgSrc: string[];
@@ -180,18 +177,18 @@ Deno.test("Security: CSP headers enforcement", () => {
 });
 
 Deno.test("Security: timestamp validation", () => {
-  const isValidTimestamp = (ts: number): boolean => {
+  let isValidTimestamp = (ts: number): boolean => {
     // Timestamp should be within last/next 5 years
-    const now = Date.now();
-    const fiveYears = 5 * 365 * 24 * 60 * 60 * 1000;
+    let now = Date.now();
+    let fiveYears = 5 * 365 * 24 * 60 * 60 * 1000;
 
     return Math.abs(now - ts) < fiveYears;
   };
 
-  const recentTs = Date.now();
-  const futureTs = Date.now() + 365 * 24 * 60 * 60 * 1000; // 1 year in future
-  const pastTs = Date.now() - 365 * 24 * 60 * 60 * 1000; // 1 year in past
-  const wayOldTs = 1000; // Year 1970
+  let recentTs = Date.now();
+  let futureTs = Date.now() + 365 * 24 * 60 * 60 * 1000; // 1 year in future
+  let pastTs = Date.now() - 365 * 24 * 60 * 60 * 1000; // 1 year in past
+  let wayOldTs = 1000; // Year 1970
 
   assertEquals(isValidTimestamp(recentTs), true);
   assertEquals(isValidTimestamp(futureTs), true);
@@ -200,7 +197,7 @@ Deno.test("Security: timestamp validation", () => {
 });
 
 Deno.test("Security: permission boundaries", () => {
-  interface Permissions {
+  struct Permissions {
     storage: boolean;
     tabs: boolean;
     webRequest: boolean;
@@ -220,4 +217,3 @@ Deno.test("Security: permission boundaries", () => {
   assertEquals(extensionPerms.webRequest, false);
 });
 
-==================================== */
diff --git a/tests/e2e/extension_lifecycle_test.affine b/tests/e2e/extension_lifecycle_test.affine
index 34602f6..07a62ef 100644
--- a/tests/e2e/extension_lifecycle_test.affine
+++ b/tests/e2e/extension_lifecycle_test.affine
@@ -1,17 +1,14 @@
 // SPDX-License-Identifier: MPL-2.0
-// Ported via Harvard Engine mechanical processor
+// Ported via Harvard Engine (Semantic pass)
 
 module extension_lifecycle_test;
 
-// TODO: Complete semantic implementation
-
-/* === ORIGINAL TYPESCRIPT CONTEXT ===
 // SPDX-License-Identifier: MPL-2.0
 // End-to-end tests for DoubleTrack extension lifecycle
 
 import { assertEquals, assertExists } from "jsr:@std/assert";
 
-interface ExtensionState {
+struct ExtensionState {
   isInitialized: boolean;
   profile?: { id: string; name: string };
   activities: Array<{ url: string; timestamp: number }>;
@@ -79,7 +76,7 @@ Deno.test("Extension lifecycle: activity accumulation", () => {
   };
 
   // Simulate adding multiple activities
-  const urls = [
+  let urls = [
     "https://example.com",
     "https://google.com",
     "https://github.com",
@@ -113,7 +110,7 @@ Deno.test("Extension lifecycle: pause and resume", () => {
 });
 
 Deno.test("Extension lifecycle: configuration persistence", () => {
-  interface ExtensionConfig {
+  struct ExtensionConfig {
     noiseLevel: number;
     profileId: string;
     enabled: boolean;
@@ -126,7 +123,7 @@ Deno.test("Extension lifecycle: configuration persistence", () => {
   };
 
   // Simulate saving and loading
-  const savedConfig = JSON.stringify(config);
+  let savedConfig = JSON.stringify(config);
   const loadedConfig: ExtensionConfig = JSON.parse(savedConfig);
 
   assertEquals(loadedConfig.noiseLevel, 0.5);
@@ -168,7 +165,7 @@ Deno.test("Extension lifecycle: state serialization", () => {
   };
 
   // Serialize
-  const serialized = JSON.stringify(initialState);
+  let serialized = JSON.stringify(initialState);
 
   // Deserialize
   const deserialized: ExtensionState = JSON.parse(serialized);
@@ -195,4 +192,3 @@ Deno.test("Extension lifecycle: profile switching", () => {
   assertEquals(state.activities.length, 0);
 });
 
-==================================== */
diff --git a/tests/property/extension_properties_test.affine b/tests/property/extension_properties_test.affine
index 02e319e..b77a3e9 100644
--- a/tests/property/extension_properties_test.affine
+++ b/tests/property/extension_properties_test.affine
@@ -1,11 +1,8 @@
 // SPDX-License-Identifier: MPL-2.0
-// Ported via Harvard Engine mechanical processor
+// Ported via Harvard Engine (Semantic pass)
 
 module extension_properties_test;
 
-// TODO: Complete semantic implementation
-
-/* === ORIGINAL TYPESCRIPT CONTEXT ===
 // SPDX-License-Identifier: MPL-2.0
 // Property-based tests for DoubleTrack extension invariants
 
@@ -13,33 +10,33 @@ import { assertEquals } from "jsr:@std/assert";
 
 Deno.test("Extension invariant: profiles never have empty names", () => {
   // Simulate profile validation
-  const validateProfile = (profile: { name: string }): boolean => {
+  let validateProfile = (profile: { name: string }): boolean => {
     return profile.name.length > 0;
   };
 
-  const validProfile = { name: "John Doe" };
-  const invalidProfile = { name: "" };
+  let validProfile = { name: "John Doe" };
+  let invalidProfile = { name: "" };
 
   assertEquals(validateProfile(validProfile), true);
   assertEquals(validateProfile(invalidProfile), false);
 });
 
 Deno.test("Extension invariant: activities always have HTTPS URLs", () => {
-  const validateActivity = (
+  let validateActivity = (
     activity: { url: string }
   ): boolean => {
     return activity.url.startsWith("https://");
   };
 
-  const validActivity = { url: "https://example.com" };
-  const invalidActivity = { url: "http://example.com" };
+  let validActivity = { url: "https://example.com" };
+  let invalidActivity = { url: "http://example.com" };
 
   assertEquals(validateActivity(validActivity), true);
   assertEquals(validateActivity(invalidActivity), false);
 });
 
 Deno.test("Extension invariant: timestamps are monotonic", () => {
-  const validateChronological = (
+  let validateChronological = (
     activities: Array<{ timestamp: number }>
   ): boolean => {
     for (let i = 1; i < activities.length; i++) {
@@ -50,13 +47,13 @@ Deno.test("Extension invariant: timestamps are monotonic", () => {
     return true;
   };
 
-  const sortedActivities = [
+  let sortedActivities = [
     { timestamp: 1000 },
     { timestamp: 2000 },
     { timestamp: 3000 },
   ];
 
-  const unsortedActivities = [
+  let unsortedActivities = [
     { timestamp: 3000 },
     { timestamp: 1000 },
     { timestamp: 2000 },
@@ -67,8 +64,8 @@ Deno.test("Extension invariant: timestamps are monotonic", () => {
 });
 
 Deno.test("Extension invariant: email format is valid", () => {
-  const validateEmail = (email: string): boolean => {
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  let validateEmail = (email: string): boolean => {
+    let emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
     return emailRegex.test(email);
   };
 
@@ -79,7 +76,7 @@ Deno.test("Extension invariant: email format is valid", () => {
 });
 
 Deno.test("Extension invariant: no null bytes in strings", () => {
-  const hasNoNullBytes = (str: string): boolean => {
+  let hasNoNullBytes = (str: string): boolean => {
     return !str.includes("\0");
   };
 
@@ -88,12 +85,12 @@ Deno.test("Extension invariant: no null bytes in strings", () => {
 });
 
 Deno.test("Extension invariant: message type is always defined", () => {
-  interface Message {
+  struct Message {
     type?: string;
     payload?: Record<string, unknown>;
   }
 
-  const validateMessage = (msg: Message): boolean => {
+  let validateMessage = (msg: Message): boolean => {
     return typeof msg.type === "string" && msg.type.length > 0;
   };
 
@@ -105,7 +102,7 @@ Deno.test("Extension invariant: message type is always defined", () => {
 });
 
 Deno.test("Extension invariant: duration is always positive", () => {
-  const validateDuration = (duration: number): boolean => {
+  let validateDuration = (duration: number): boolean => {
     return duration > 0 && Number.isFinite(duration);
   };
 
@@ -116,7 +113,7 @@ Deno.test("Extension invariant: duration is always positive", () => {
 });
 
 Deno.test("Extension invariant: interests array is never empty", () => {
-  const validateInterests = (interests: string[]): boolean => {
+  let validateInterests = (interests: string[]): boolean => {
     return Array.isArray(interests) && interests.length > 0;
   };
 
@@ -126,7 +123,7 @@ Deno.test("Extension invariant: interests array is never empty", () => {
 });
 
 Deno.test("Extension invariant: activity type is known", () => {
-  const VALID_ACTIVITY_TYPES = [
+  let VALID_ACTIVITY_TYPES = [
     "Search",
     "PageVisit",
     "VideoWatch",
@@ -136,7 +133,7 @@ Deno.test("Extension invariant: activity type is known", () => {
     "Research",
   ];
 
-  const validateActivityType = (type: string): boolean => {
+  let validateActivityType = (type: string): boolean => {
     return VALID_ACTIVITY_TYPES.includes(type);
   };
 
@@ -145,4 +142,3 @@ Deno.test("Extension invariant: activity type is known", () => {
   assertEquals(validateActivityType("InvalidType"), false);
 });
 
-==================================== */
diff --git a/tests/unit/types_test.affine b/tests/unit/types_test.affine
index e95211b..0b0f475 100644
--- a/tests/unit/types_test.affine
+++ b/tests/unit/types_test.affine
@@ -1,18 +1,15 @@
 // SPDX-License-Identifier: MPL-2.0
-// Ported via Harvard Engine mechanical processor
+// Ported via Harvard Engine (Semantic pass)
 
 module types_test;
 
-// TODO: Complete semantic implementation
-
-/* === ORIGINAL TYPESCRIPT CONTEXT ===
 // SPDX-License-Identifier: MPL-2.0
 // Unit tests for DoubleTrack TypeScript type contracts
 
 import { assertEquals, assertExists, assertStringIncludes } from "jsr:@std/assert";
 
 Deno.test("Extension message types", () => {
-  interface ContentMessage {
+  struct ContentMessage {
     type: string;
     payload?: Record<string, unknown>;
   }
@@ -27,7 +24,7 @@ Deno.test("Extension message types", () => {
 });
 
 Deno.test("Storage schema validation", () => {
-  interface StoredProfile {
+  struct StoredProfile {
     id: string;
     name: string;
     interests: string[];
@@ -47,7 +44,7 @@ Deno.test("Storage schema validation", () => {
 });
 
 Deno.test("Form data contract", () => {
-  interface FormData {
+  struct FormData {
     email: string;
     displayName: string;
     preferences: string[];
@@ -66,7 +63,7 @@ Deno.test("Form data contract", () => {
 });
 
 Deno.test("Activity log schema", () => {
-  interface BrowsingActivity {
+  struct BrowsingActivity {
     url: string;
     title: string;
     duration_seconds: number;
@@ -86,4 +83,3 @@ Deno.test("Activity log schema", () => {
   assertEquals(activity.duration_seconds > 0, true);
 });
 
-==================================== */