codexgpt 1.0.0

package/scripts/test-performance-reporter.mjs

@@ -0,0 +1,291 @@
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+const repositoryRoot = path.resolve(scriptDirectory, "..");
+const testRoot = path.join(repositoryRoot, "test");
+const REPORT_MAX_BYTES = 2 * 1024 * 1024;
+
+function boundedLabel(value, fallback = "unknown") {
+  if (typeof value !== "string" || value.length === 0 || value.length > 100) return fallback;
+  return /^[A-Za-z0-9._-]+$/.test(value) ? value : fallback;
+}
+
+function relativeTestPath(file) {
+  if (typeof file !== "string" || file.length === 0) return null;
+  let absolutePath;
+  try {
+    absolutePath = file.startsWith("file:") ? fileURLToPath(file) : path.resolve(repositoryRoot, file);
+  } catch {
+    return null;
+  }
+  const relative = path.relative(testRoot, absolutePath);
+  if (
+    relative.length === 0 ||
+    relative.startsWith(`..${path.sep}`) ||
+    relative === ".." ||
+    path.isAbsolute(relative) ||
+    !relative.endsWith(".test.mjs")
+  ) {
+    return null;
+  }
+  return `test/${relative.split(path.sep).join("/")}`;
+}
+
+function iso(timestamp) {
+  return new Date(timestamp).toISOString();
+}
+
+function identity(stat) {
+  return `${stat.dev}:${stat.ino}`;
+}
+
+function stableFacts(stat) {
+  return `${identity(stat)}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+}
+
+async function inspectDirectory(target, expectedRoot, expectedRelative) {
+  const stat = await fsp.lstat(target, { bigint: true });
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error(`Performance path must be a real directory: ${expectedRelative}`);
+  }
+  const real = await fsp.realpath(target);
+  const relative = path.relative(expectedRoot, real).split(path.sep).join("/");
+  if (relative !== expectedRelative) {
+    throw new Error(`Performance path escaped the repository: ${expectedRelative}`);
+  }
+  return { path: target, real, identity: identity(stat) };
+}
+
+async function createDirectory(target) {
+  try {
+    await fsp.mkdir(target);
+  } catch (error) {
+    if (error?.code !== "EEXIST") throw error;
+  }
+}
+
+export async function prepareTestPerformanceDirectory(root = repositoryRoot) {
+  const rootReal = await fsp.realpath(root);
+  const bridge = path.join(root, ".ai-bridge");
+  const performance = path.join(bridge, "performance");
+  await createDirectory(bridge);
+  const bridgeState = await inspectDirectory(bridge, rootReal, ".ai-bridge");
+  await createDirectory(performance);
+  const performanceState = await inspectDirectory(performance, rootReal, ".ai-bridge/performance");
+  return { rootReal, bridge: bridgeState, performance: performanceState };
+}
+
+export async function verifyTestPerformanceDirectory(state) {
+  const bridge = await inspectDirectory(state.bridge.path, state.rootReal, ".ai-bridge");
+  const performance = await inspectDirectory(
+    state.performance.path,
+    state.rootReal,
+    ".ai-bridge/performance"
+  );
+  if (bridge.identity !== state.bridge.identity || performance.identity !== state.performance.identity) {
+    throw new Error("Performance directory identity changed while tests were running.");
+  }
+}
+
+function exactKeys(value, expected, label) {
+  assertObject(value, label);
+  const actual = Object.keys(value).sort();
+  const wanted = [...expected].sort();
+  if (actual.length !== wanted.length || actual.some((key, index) => key !== wanted[index])) {
+    throw new Error(`${label} has unexpected fields.`);
+  }
+}
+
+function assertObject(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object.`);
+  }
+}
+
+export async function validateTestPerformanceReport(
+  reportPath,
+  {
+    domain,
+    shard,
+    testNames,
+    platform = process.platform,
+    nodeVersion = process.version,
+    environment = process.env
+  }
+) {
+  const handle = await fsp.open(reportPath, "r");
+  try {
+    const before = await handle.stat({ bigint: true });
+    if (!before.isFile() || before.nlink !== 1n || before.size <= 0n || before.size > BigInt(REPORT_MAX_BYTES)) {
+      throw new Error("Performance report must be one bounded single-link regular file.");
+    }
+    const buffer = Buffer.alloc(REPORT_MAX_BYTES + 1);
+    let loaded = 0;
+    while (loaded < buffer.length) {
+      const { bytesRead } = await handle.read(buffer, loaded, buffer.length - loaded, loaded);
+      if (bytesRead === 0) break;
+      loaded += bytesRead;
+    }
+    if (loaded > REPORT_MAX_BYTES) throw new Error("Performance report exceeded its read bound.");
+    const text = buffer.subarray(0, loaded).toString("utf8");
+    const after = await handle.stat({ bigint: true });
+    if (stableFacts(before) !== stableFacts(after) || BigInt(loaded) !== after.size) {
+      throw new Error("Performance report stable facts changed while it was read.");
+    }
+    const report = JSON.parse(text);
+    exactKeys(
+      report,
+      ["schemaVersion", "domain", "shard", "startedAt", "endedAt", "durationMs", "runtime", "ci", "testFiles"],
+      "Performance report"
+    );
+    if (report.schemaVersion !== 1 || report.domain !== domain || report.shard !== shard) {
+      throw new Error("Performance report context does not match the test invocation.");
+    }
+    if (
+      !Number.isFinite(Date.parse(report.startedAt)) ||
+      !Number.isFinite(Date.parse(report.endedAt)) ||
+      !Number.isFinite(report.durationMs) ||
+      report.durationMs < 0
+    ) {
+      throw new Error("Performance report has invalid aggregate timing metadata.");
+    }
+    exactKeys(report.runtime, ["platform", "architecture", "nodeVersion"], "Performance runtime");
+    if (
+      report.runtime.platform !== platform ||
+      report.runtime.architecture !== process.arch ||
+      report.runtime.nodeVersion !== nodeVersion
+    ) {
+      throw new Error("Performance report runtime does not match the test process.");
+    }
+    if (report.ci !== null) {
+      exactKeys(report.ci, ["provider", "runId", "runAttempt", "job"], "Performance CI context");
+      if (
+        report.ci.provider !== "github-actions" ||
+        [report.ci.runId, report.ci.runAttempt, report.ci.job]
+          .some((value) => boundedLabel(value) !== value)
+      ) {
+        throw new Error("Performance report contains invalid CI context.");
+      }
+    }
+    if (environment.GITHUB_ACTIONS === "true") {
+      const expectedCi = {
+        provider: "github-actions",
+        runId: boundedLabel(environment.GITHUB_RUN_ID),
+        runAttempt: boundedLabel(environment.GITHUB_RUN_ATTEMPT),
+        job: boundedLabel(environment.GITHUB_JOB)
+      };
+      if (
+        Object.values(expectedCi).includes("unknown") ||
+        report.ci === null ||
+        Object.entries(expectedCi).some(([key, value]) => report.ci[key] !== value)
+      ) {
+        throw new Error("Performance report does not match the current GitHub Actions context.");
+      }
+    }
+    if (!Array.isArray(report.testFiles)) throw new Error("Performance testFiles must be an array.");
+    const expected = new Set(testNames.map((name) => `test/${name}`));
+    const actual = new Set();
+    for (const entry of report.testFiles) {
+      exactKeys(entry, ["test", "status", "startedAt", "endedAt", "durationMs"], "Performance test file");
+      if (!expected.has(entry.test) || actual.has(entry.test) || path.isAbsolute(entry.test)) {
+        throw new Error("Performance report contains an unexpected or duplicate test path.");
+      }
+      if (!["passed", "failed"].includes(entry.status)) {
+        throw new Error("Performance report contains an invalid test status.");
+      }
+      if (
+        !Number.isFinite(Date.parse(entry.startedAt)) ||
+        !Number.isFinite(Date.parse(entry.endedAt)) ||
+        !Number.isFinite(entry.durationMs) ||
+        entry.durationMs < 0
+      ) {
+        throw new Error("Performance report contains invalid timing metadata.");
+      }
+      actual.add(entry.test);
+    }
+    if (actual.size !== expected.size) throw new Error("Performance report is missing test files.");
+    return report;
+  } finally {
+    await handle.close();
+  }
+}
+
+export function createTestPerformanceReporter({
+  now = Date.now,
+  environment = process.env,
+  platform = process.platform,
+  architecture = process.arch,
+  nodeVersion = process.version
+} = {}) {
+  return async function* testPerformanceReporter(source) {
+    const files = new Map();
+    let reportStartedAt = null;
+    let reportEndedAt = null;
+
+    for await (const event of source) {
+      const timestamp = now();
+      reportStartedAt ??= timestamp;
+      reportEndedAt = timestamp;
+      const test = relativeTestPath(event?.data?.file);
+      if (test === null) continue;
+
+      const current = files.get(test) ?? {
+        test,
+        status: "unknown",
+        firstObservedAt: timestamp,
+        startedAt: null,
+        endedAt: null,
+        lastObservedAt: timestamp
+      };
+      current.lastObservedAt = timestamp;
+      if (event.type === "test:dequeue") current.startedAt ??= timestamp;
+      if (event.type === "test:complete") current.endedAt = timestamp;
+      if (event.type === "test:fail") current.status = "failed";
+      if (event.type === "test:pass" && current.status !== "failed") current.status = "passed";
+      files.set(test, current);
+    }
+
+    const testFiles = [...files.values()]
+      .map((entry) => {
+        const startedAt = entry.startedAt ?? entry.firstObservedAt;
+        const endedAt = entry.endedAt ?? entry.lastObservedAt;
+        return {
+          test: entry.test,
+          status: entry.status,
+          startedAt: iso(startedAt),
+          endedAt: iso(endedAt),
+          durationMs: Math.max(0, endedAt - startedAt)
+        };
+      })
+      .sort((left, right) => right.durationMs - left.durationMs || left.test.localeCompare(right.test));
+
+    const githubActions = environment.GITHUB_ACTIONS === "true";
+    const report = {
+      schemaVersion: 1,
+      domain: boundedLabel(environment.CODEXGPT_TEST_PERFORMANCE_DOMAIN),
+      shard: boundedLabel(environment.CODEXGPT_TEST_PERFORMANCE_SHARD),
+      startedAt: reportStartedAt === null ? null : iso(reportStartedAt),
+      endedAt: reportEndedAt === null ? null : iso(reportEndedAt),
+      durationMs: reportStartedAt === null ? 0 : Math.max(0, reportEndedAt - reportStartedAt),
+      runtime: {
+        platform,
+        architecture,
+        nodeVersion
+      },
+      ci: githubActions
+        ? {
+            provider: "github-actions",
+            runId: boundedLabel(environment.GITHUB_RUN_ID),
+            runAttempt: boundedLabel(environment.GITHUB_RUN_ATTEMPT),
+            job: boundedLabel(environment.GITHUB_JOB)
+          }
+        : null,
+      testFiles
+    };
+    yield `${JSON.stringify(report, null, 2)}\n`;
+  };
+}
+
+export default createTestPerformanceReporter();

package/scripts/toolchain-manager.mjs

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+import { createHash } from "node:crypto";
+import { spawn, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { writeJsonAtomicFile } from "./atomic-file.mjs";
+import { createOwnedTempRoot } from "./owned-temp-root.mjs";
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const spec = JSON.parse(await fsp.readFile(path.join(scriptDir, "toolchains.json"), "utf8"));
+const argv = process.argv.slice(2);
+const action = argv[0] ?? "status";
+
+function option(name, fallback) {
+  const index = argv.indexOf(name);
+  return index === -1 ? fallback : argv[index + 1];
+}
+
+function fail(message, detail, code = 1) {
+  console.error(message);
+  if (detail) console.error(detail);
+  process.exit(code);
+}
+
+function stableRoot() {
+  if (option("--root")) return path.resolve(option("--root"));
+  if (process.platform !== "win32") fail("The pinned local toolchain manager currently supports native Windows only.");
+  const localAppData = process.env.LOCALAPPDATA?.trim()
+    ? process.env.LOCALAPPDATA
+    : process.env.USERPROFILE
+      ? path.win32.join(process.env.USERPROFILE, "AppData", "Local")
+      : undefined;
+  if (!localAppData) fail("LOCALAPPDATA or USERPROFILE is required to locate the stable toolchain root.");
+  return path.join(localAppData, "CodexGPT", "toolchains");
+}
+
+function requestedMajors() {
+  const value = String(option("--major", "all"));
+  if (value === "all") return Object.keys(spec.toolchains);
+  if (!spec.toolchains[value]) fail(`Unknown Node major ${value}; expected ${Object.keys(spec.toolchains).join(", ")}.`, undefined, 2);
+  return [value];
+}
+
+function toolchainPaths(root, major) {
+  const entry = spec.toolchains[major];
+  const directoryName = entry.archive.replace(/\.zip$/i, "");
+  const directory = path.join(root, directoryName);
+  return {
+    entry,
+    directory,
+    node: path.join(directory, "node.exe"),
+    npmCli: path.join(directory, "node_modules", "npm", "bin", "npm-cli.js")
+  };
+}
+
+function runVersion(nodePath) {
+  const result = spawnSync(nodePath, ["--version"], { encoding: "utf8", windowsHide: true });
+  return result.status === 0 ? result.stdout.trim() : undefined;
+}
+
+async function hashFile(file) {
+  const hash = createHash("sha256");
+  await new Promise((resolve, reject) => {
+    const stream = fs.createReadStream(file);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", resolve);
+  });
+  return hash.digest("hex");
+}
+
+async function download(url, destination) {
+  const response = await fetch(url, { redirect: "follow" });
+  if (!response.ok || !response.body) throw new Error(`Download failed (${response.status}) for ${url}`);
+  const file = fs.createWriteStream(destination, { flags: "wx" });
+  await new Promise(async (resolve, reject) => {
+    file.on("error", reject);
+    try {
+      for await (const chunk of response.body) {
+        if (!file.write(chunk)) await new Promise((drain) => file.once("drain", drain));
+      }
+      file.end(resolve);
+    } catch (error) {
+      file.destroy();
+      reject(error);
+    }
+  });
+}
+
+function expectedDigest(shasumsText, archive) {
+  const line = shasumsText.split(/\r?\n/).find((candidate) => candidate.trim().endsWith(`  ${archive}`));
+  if (!line) throw new Error(`Official SHASUMS256.txt does not contain ${archive}.`);
+  const digest = line.trim().split(/\s+/)[0];
+  if (!/^[0-9a-f]{64}$/i.test(digest)) throw new Error(`Invalid official SHA-256 entry for ${archive}.`);
+  return digest.toLowerCase();
+}
+
+function extractZip(archive, destination) {
+  const quotePowerShellLiteral = (value) => `'${String(value).replace(/'/g, "''")}'`;
+  const script = `Expand-Archive -LiteralPath ${quotePowerShellLiteral(archive)} -DestinationPath ${quotePowerShellLiteral(destination)} -Force`;
+  const command = [
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy", "Bypass",
+    "-Command",
+    script
+  ];
+  const result = spawnSync("powershell.exe", command, { encoding: "utf8", windowsHide: true, maxBuffer: 4 * 1024 * 1024 });
+  if (result.status !== 0) throw new Error(`PowerShell Expand-Archive failed: ${result.stderr || result.stdout}`);
+}
+
+async function readManifest(root) {
+  try {
+    return JSON.parse(await fsp.readFile(path.join(root, "manifest.json"), "utf8"));
+  } catch (error) {
+    if (error?.code === "ENOENT") return { schemaVersion: 1, installations: {} };
+    throw error;
+  }
+}
+
+async function writeManifest(root, manifest) {
+  await writeJsonAtomicFile(path.join(root, "manifest.json"), manifest);
+}
+
+async function installMajor(root, major) {
+  const { entry, directory, node } = toolchainPaths(root, major);
+  const existing = runVersion(node);
+  if (existing === `v${entry.version}`) return { major, status: "present", version: existing, directory };
+  if (await fsp.stat(directory).then(() => true, () => false)) {
+    fail(`Refusing to overwrite mismatched toolchain directory ${directory}. Relocate it manually before retrying.`);
+  }
+
+  await fsp.mkdir(root, { recursive: true });
+  const ownedTemp = await createOwnedTempRoot(`node-${major}`);
+  const tempRoot = ownedTemp.path;
+  const archivePath = path.join(tempRoot, entry.archive);
+  const shasumsUrl = `${spec.distribution}/v${entry.version}/${entry.shasums}`;
+  const archiveUrl = `${spec.distribution}/v${entry.version}/${entry.archive}`;
+  try {
+    const shasumsResponse = await fetch(shasumsUrl, { redirect: "follow" });
+    if (!shasumsResponse.ok) throw new Error(`Download failed (${shasumsResponse.status}) for ${shasumsUrl}`);
+    const shasumsText = await shasumsResponse.text();
+    const officialSha256 = expectedDigest(shasumsText, entry.archive);
+    await download(archiveUrl, archivePath);
+    const archiveSha256 = await hashFile(archivePath);
+    if (archiveSha256 !== officialSha256) {
+      throw new Error(`SHA-256 mismatch for ${entry.archive}: expected ${officialSha256}, received ${archiveSha256}.`);
+    }
+
+    const extractRoot = path.join(tempRoot, "extract");
+    await fsp.mkdir(extractRoot);
+    extractZip(archivePath, extractRoot);
+    const extracted = path.join(extractRoot, entry.archive.replace(/\.zip$/i, ""));
+    const extractedVersion = runVersion(path.join(extracted, "node.exe"));
+    if (extractedVersion !== `v${entry.version}`) throw new Error(`Extracted runtime reported ${extractedVersion ?? "no version"}.`);
+    await fsp.rename(extracted, directory);
+
+    const manifest = await readManifest(root);
+    manifest.schemaVersion = 1;
+    manifest.installations ??= {};
+    manifest.installations[major] = {
+      tool: "node",
+      major: Number(major),
+      version: entry.version,
+      platform: entry.platform,
+      source: "official-node-distribution",
+      archive: entry.archive,
+      archiveUrl,
+      shasumsUrl,
+      archiveSha256,
+      installedPath: directory,
+      nodeExecutable: node,
+      verifiedAt: new Date().toISOString()
+    };
+    await writeManifest(root, manifest);
+    return { major, status: "installed", version: extractedVersion, directory, archiveSha256 };
+  } finally {
+    await ownedTemp.cleanup();
+  }
+}
+
+async function status(root) {
+  const manifest = await readManifest(root);
+  return {
+    schemaVersion: 1,
+    root,
+    manifestPath: path.join(root, "manifest.json"),
+    toolchains: Object.fromEntries(Object.keys(spec.toolchains).map((major) => {
+      const paths = toolchainPaths(root, major);
+      const reported = runVersion(paths.node);
+      const record = manifest.installations?.[major] ?? null;
+      return [major, {
+        expectedVersion: `v${paths.entry.version}`,
+        reportedVersion: reported ?? null,
+        ready: reported === `v${paths.entry.version}` && record?.archiveSha256?.length === 64,
+        directory: paths.directory,
+        supplyChainRecord: record
+      }];
+    }))
+  };
+}
+
+function execution(root, major, command) {
+  const paths = toolchainPaths(root, major);
+  if (runVersion(paths.node) !== `v${paths.entry.version}`) fail(`Node ${major} is not ready. Run toolchain:ensure first.`);
+  const [program, ...programArgs] = command;
+  if (!program) fail("Missing command after --.", undefined, 2);
+  const env = {
+    ...process.env,
+    PATH: `${paths.directory}${path.delimiter}${process.env.PATH ?? ""}`,
+    NODE: paths.node,
+    npm_node_execpath: paths.node
+  };
+  if (program === "node") return { executable: paths.node, args: programArgs, env };
+  if (program === "npm") {
+    return {
+      executable: paths.node,
+      args: [paths.npmCli, ...programArgs],
+      env: { ...env, npm_execpath: paths.npmCli }
+    };
+  }
+  return { executable: program, args: programArgs, env };
+}
+
+async function runOne(root, major, command) {
+  const selected = execution(root, major, command);
+  const child = spawn(selected.executable, selected.args, {
+    cwd: process.cwd(),
+    env: selected.env ?? process.env,
+    shell: false,
+    windowsHide: true,
+    stdio: "inherit"
+  });
+  return await new Promise((resolve) => {
+    child.once("error", (error) => {
+      console.error(error.stack ?? error.message);
+      resolve(127);
+    });
+    child.once("close", (code) => resolve(code ?? 1));
+  });
+}
+
+const root = stableRoot();
+if (action === "status") {
+  console.log(JSON.stringify(await status(root), null, 2));
+} else if (action === "ensure") {
+  const results = [];
+  for (const major of requestedMajors()) results.push(await installMajor(root, major));
+  console.log(JSON.stringify({ root, results }, null, 2));
+} else if (action === "exec" || action === "matrix") {
+  const separator = argv.indexOf("--");
+  if (separator === -1 || separator === argv.length - 1) fail(`${action} requires -- <command> [args...].`, undefined, 2);
+  const command = argv.slice(separator + 1);
+  const majors = action === "matrix" ? requestedMajors() : [String(option("--major"))];
+  if (majors.some((major) => !spec.toolchains[major])) fail("exec requires --major 20 or --major 24.", undefined, 2);
+  for (const major of majors) {
+    console.log(`\n=== Node ${major} (${spec.toolchains[major].version}) ===`);
+    const code = await runOne(root, major, command);
+    if (code !== 0) process.exit(code);
+  }
+} else {
+  fail("Usage: node scripts/toolchain-manager.mjs <status|ensure|exec|matrix> [--major 20|24|all] [--root <dir>] [-- <command> ...]", undefined, 2);
+}

package/scripts/toolchains.json

@@ -0,0 +1,19 @@
+{
+  "schemaVersion": 1,
+  "stableRoot": "%LOCALAPPDATA%\\CodexGPT\\toolchains",
+  "distribution": "https://nodejs.org/dist",
+  "toolchains": {
+    "20": {
+      "version": "20.20.2",
+      "platform": "win-x64",
+      "archive": "node-v20.20.2-win-x64.zip",
+      "shasums": "SHASUMS256.txt"
+    },
+    "24": {
+      "version": "24.15.0",
+      "platform": "win-x64",
+      "archive": "node-v24.15.0-win-x64.zip",
+      "shasums": "SHASUMS256.txt"
+    }
+  }
+}

package/scripts/windows-conpty-probe-child.mjs

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+const READY = "CXP4_CONPTY_READY";
+const INPUT_ACK = "CXP4_INPUT_ACK";
+const ETX_ACK = "CXP4_ETX_ACK";
+const PROBE_TIMEOUT_MS = 20_000;
+
+let buffered = Buffer.alloc(0);
+let etxAcknowledged = false;
+let exiting = false;
+
+function writeLine(value) {
+  process.stdout.write(`${value}\r\n`);
+}
+
+function acknowledgeEtx() {
+  if (etxAcknowledged || exiting) return;
+  etxAcknowledged = true;
+  writeLine(ETX_ACK);
+}
+
+function fail(code) {
+  if (exiting) return;
+  exiting = true;
+  process.stderr.write(`${code}\n`);
+  process.exitCode = 1;
+  process.stdin.pause();
+}
+
+function finish() {
+  if (exiting) return;
+  exiting = true;
+  process.exitCode = etxAcknowledged ? 0 : 1;
+  process.stdin.pause();
+}
+
+function consumeLines() {
+  while (true) {
+    const newline = buffered.indexOf(0x0a);
+    if (newline < 0) return;
+    const line = buffered.subarray(0, newline).toString("utf8").replace(/\r$/, "");
+    buffered = buffered.subarray(newline + 1);
+    if (line === "CXP4_INPUT") {
+      writeLine(INPUT_ACK);
+    } else if (line === "CXP4_EXIT") {
+      finish();
+      return;
+    } else if (line.length > 0) {
+      fail("CXP4_PROBE_COMMAND_INVALID");
+      return;
+    }
+  }
+}
+
+process.on("SIGINT", acknowledgeEtx);
+process.stdin.on("data", (chunk) => {
+  if (exiting) return;
+  const incoming = Buffer.from(chunk);
+  const retained = [];
+  for (const byte of incoming) {
+    if (byte === 0x03) acknowledgeEtx();
+    else retained.push(byte);
+  }
+  if (retained.length > 0) {
+    buffered = Buffer.concat([buffered, Buffer.from(retained)]);
+    if (buffered.length > 4096) return fail("CXP4_PROBE_INPUT_TOO_LARGE");
+    consumeLines();
+  }
+});
+process.stdin.on("end", () => {
+  if (!exiting) fail("CXP4_PROBE_INPUT_CLOSED");
+});
+process.stdin.on("error", () => fail("CXP4_PROBE_INPUT_FAILED"));
+
+if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+  process.stdin.setRawMode(true);
+}
+process.stdin.resume();
+writeLine(READY);
+
+const timeout = setTimeout(() => fail("CXP4_PROBE_TIMEOUT"), PROBE_TIMEOUT_MS);
+timeout.unref?.();

package/scripts/windows-conpty-worker.ps1

@@ -0,0 +1,24 @@
+param(
+    [switch]$SimulateCloseHang,
+    [switch]$Persistent,
+    [string]$NodeExecutable,
+    [string]$ProbeScript
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+
+$scriptRoot = [System.IO.Path]::GetFullPath($PSScriptRoot)
+$sourcePath = [System.IO.Path]::Combine($scriptRoot, 'windows-process-host.cs')
+if (-not [System.IO.File]::Exists($sourcePath)) {
+    [Console]::Error.WriteLine('CONPTY_WORKER_SOURCE_MISSING')
+    exit 2
+}
+
+Add-Type -Path $sourcePath -ReferencedAssemblies @('System.Web.Extensions') -ErrorAction Stop | Out-Null
+if ($Persistent.IsPresent) {
+    [CodexGPT.Phase4.ProcessHost]::RunConPtyPersistentWorker()
+    exit [Environment]::ExitCode
+}
+[CodexGPT.Phase4.ProcessHost]::RunConPtyWorker($SimulateCloseHang.IsPresent, $NodeExecutable, $ProbeScript)
+exit [Environment]::ExitCode