sneakoscope 8.0.2 → 8.0.4

package/dist/scripts/zellij-real-session-launch-check.js

@@ -1,126 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import { createHash } from 'node:crypto';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
-const freshness = ensureDistFresh({ rebuild: true });
-if (!freshness.ok)
-    fail('dist_not_fresh', { freshness });
-const args = process.argv.slice(2);
-const runSuffix = `${process.pid}-${Date.now().toString(36)}`;
-const missionId = readArg(args, '--mission') || `M-zellij-real-check-${runSuffix}`;
-const sessionName = readArg(args, '--session') || `sks-real-${runSuffix}`;
-const requireReal = process.env.SKS_REQUIRE_ZELLIJ === '1' || args.includes('--require-real');
-const mainOnly = args.includes('--main-only') || process.env.SKS_ZELLIJ_MAIN_ONLY === '1';
-const ownedSession = args.includes('--owned-session');
-const ownerToken = String(process.env.SKS_ZELLIJ_CHECK_OWNER_TOKEN || '');
-const launcher = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-launcher.js')).href);
-const command = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-command.js')).href);
-const screenProof = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-screen-proof.js')).href);
-const socketDir = command.resolveZellijProcessEnvMeta().zellij_socket_dir;
-const missionRoot = path.join(root, '.sneakoscope', 'missions', missionId);
-const ownershipPath = path.join(missionRoot, 'zellij-real-session-ownership.json');
-const expectedLayoutPath = path.join(root, '.sneakoscope', 'layouts', `mad-${missionId}.kdl`);
-let ownership = null;
-if (ownedSession) {
-    if (!isSafeOwnedSocketDir(socketDir))
-        fail('zellij_owned_socket_dir_invalid', { socket_dir: socketDir });
-    if (ownerToken.length < 32)
-        fail('zellij_owner_token_missing', { owner_token_present: ownerToken.length > 0 });
-    const [markerExists, socketExists] = await Promise.all([exists(ownershipPath), exists(socketDir)]);
-    if (markerExists)
-        fail('zellij_ownership_marker_collision', { ownership_path: ownershipPath });
-    if (socketExists)
-        fail('zellij_owned_socket_dir_collision', { socket_dir: socketDir });
-    ownership = {
-        schema: 'sks.zellij-real-session-ownership.v1',
-        mission_id: missionId,
-        session_name: sessionName,
-        socket_dir: socketDir,
-        owner_token_sha256: hashOwnerToken(ownerToken),
-        cleanup_authorized: true,
-        layout_cleanup_authorized: true,
-        layout_path: expectedLayoutPath,
-        layout_sha256: null,
-        state: 'prepared',
-        session_created: false
-    };
-    await fs.mkdir(missionRoot, { recursive: true });
-    await fs.writeFile(ownershipPath, `${JSON.stringify(ownership, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
-}
-const report = await launcher.launchMadZellijUi(['--session', sessionName], {
-    root,
-    missionId,
-    ledgerRoot: path.join(root, '.sneakoscope', 'missions', missionId, 'agents'),
-    dryRun: false,
-    requireZellij: requireReal,
-    slotCount: 1
-});
-const sessionCollision = Array.isArray(report?.launch?.create_background?.warnings)
-    && report.launch.create_background.warnings.some((warning) => String(warning).startsWith('zellij_session_already_exists:'));
-const layoutPathValid = !ownedSession || path.resolve(String(report?.layout_path || '')) === path.resolve(expectedLayoutPath);
-const layoutSha256 = ownedSession && layoutPathValid ? await sha256File(expectedLayoutPath) : null;
-if (ownership) {
-    ownership = {
-        ...ownership,
-        state: report?.launch?.create_background?.ok === true && !sessionCollision ? 'launched' : 'launch_failed',
-        session_created: report?.launch?.create_background?.ok === true && !sessionCollision,
-        layout_path_valid: layoutPathValid,
-        layout_sha256: layoutSha256,
-        launch_exit_code: report?.launch?.create_background?.exit_code ?? null
-    };
-    await fs.writeFile(ownershipPath, `${JSON.stringify(ownership, null, 2)}\n`, { mode: 0o600 });
-}
-const heartbeatPath = path.join(root, '.sneakoscope', 'missions', missionId, 'zellij-lane-renderer-heartbeat.jsonl');
-const heartbeat = mainOnly
-    ? { ok: true, heartbeat_present: false, waited_ms: 0, timeout_ms: 0, blocker: null, skipped: true }
-    : await screenProof.waitForLaneHeartbeat(heartbeatPath, { timeoutMs: 5000 });
-const blockers = [
-    ...(sessionCollision ? ['zellij_session_name_collision'] : []),
-    ...(ownedSession && !layoutPathValid ? ['zellij_owned_layout_path_invalid'] : []),
-    ...(ownedSession && !layoutSha256 ? ['zellij_owned_layout_hash_missing'] : []),
-    ...(requireReal && report.ok !== true ? ['zellij_real_session_launch_failed'] : []),
-    ...(requireReal && heartbeat.blocker ? [heartbeat.blocker] : [])
-];
-const gate = {
-    schema: 'sks.zellij-real-session-launch-check.v1',
-    ok: requireReal ? (report.ok === true && heartbeat.ok === true && blockers.length === 0) : (report.ok === true && blockers.length === 0),
-    integration_optional: !requireReal,
-    main_only: mainOnly,
-    mission_id: missionId,
-    session_name: sessionName,
-    owned_session: ownedSession,
-    ownership_path: ownership ? ownershipPath : null,
-    socket_dir: socketDir,
-    heartbeat: { path: heartbeatPath, present: heartbeat.heartbeat_present, waited_ms: heartbeat.waited_ms, timeout_ms: heartbeat.timeout_ms },
-    blockers,
-    report
-};
-await fs.mkdir(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
-await fs.writeFile(path.join(root, '.sneakoscope', 'reports', 'zellij-real-session-launch.json'), `${JSON.stringify(gate, null, 2)}\n`);
-emit(gate);
-function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
-    process.exitCode = 1; }
-function fail(blocker, detail) { emit({ schema: 'sks.zellij-real-session-launch-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
-function readArg(args, name) {
-    const index = args.indexOf(name);
-    return index >= 0 ? args[index + 1] || null : null;
-}
-function hashOwnerToken(value) {
-    return createHash('sha256').update(String(value)).digest('hex');
-}
-async function sha256File(file) {
-    return fs.readFile(file).then((data) => createHash('sha256').update(data).digest('hex')).catch(() => null);
-}
-function isSafeOwnedSocketDir(value) {
-    if (!value)
-        return false;
-    const resolved = path.resolve(String(value));
-    return path.dirname(resolved) === '/tmp' && /^sks-zj-rr-[A-Za-z0-9-]+$/.test(path.basename(resolved));
-}
-async function exists(value) {
-    if (!value)
-        return false;
-    return fs.access(value).then(() => true).catch(() => false);
-}

package/dist/scripts/zellij-screen-proof-check.js

@@ -1,43 +0,0 @@
-#!/usr/bin/env node
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
-const freshness = ensureDistFresh({ rebuild: true });
-if (!freshness.ok)
-    fail('dist_not_fresh', { freshness });
-const mod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-screen-proof.js')).href);
-const args = process.argv.slice(2);
-const missionId = readArg(args, '--mission');
-const mainOnly = args.includes('--main-only') || process.env.SKS_ZELLIJ_MAIN_ONLY === '1';
-if (missionId && !mainOnly)
-    await waitForHeartbeat([
-        path.join(root, '.sneakoscope', 'missions', missionId, 'zellij-lane-renderer-heartbeat.jsonl'),
-        path.join(root, '.sneakoscope', 'missions', missionId, 'agents', 'zellij-lane-renderer-heartbeat.jsonl')
-    ]);
-const report = await mod.writeZellijScreenProof(root, {
-    require: process.env.SKS_REQUIRE_ZELLIJ === '1' || args.includes('--require-real'),
-    missionId: missionId || undefined,
-    ledgerRoot: missionId ? path.join(root, '.sneakoscope', 'missions', missionId) : undefined,
-    mainOnly
-});
-const requiredTextOk = ['SKS Lane', 'Mission', 'Mode', 'Workers', 'Current', 'Queue', 'Safety', 'Blockers', 'Reports', 'Keys:'].every((label) => report.required_text?.includes(label));
-emit({ ...report, required_text_fixture_ok: requiredTextOk, ok: report.ok && requiredTextOk });
-function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
-    process.exitCode = 1; }
-function fail(blocker, detail) { emit({ schema: 'sks.zellij-screen-proof-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
-function readArg(args, name) {
-    const index = args.indexOf(name);
-    return index >= 0 ? args[index + 1] || null : null;
-}
-async function waitForHeartbeat(files) {
-    const fs = await import('node:fs/promises');
-    const deadline = Date.now() + 5000;
-    while (Date.now() < deadline) {
-        for (const file of files) {
-            const text = await fs.readFile(file, 'utf8').catch(() => '');
-            if (text.trim())
-                return;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 250));
-    }
-}

package/schemas/zellij/zellij-right-column-state.schema.json

@@ -1,40 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "sks.zellij-right-column-state.v1",
-  "type": "object",
-  "required": ["schema", "mission_id", "session_name", "status", "visible_worker_panes", "headless_workers", "blockers"],
-  "properties": {
-    "schema": { "const": "sks.zellij-right-column-state.v1" },
-    "mission_id": { "type": "string" },
-    "session_name": { "type": "string" },
-    "status": { "enum": ["absent", "creating", "active", "draining", "closed"] },
-    "right_anchor_pane_id": { "type": ["string", "null"] },
-    "visible_worker_panes": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "required": ["slot_id", "generation_index", "y_order", "status"],
-        "properties": {
-          "pane_id": { "type": ["string", "null"] },
-          "slot_id": { "type": "string" },
-          "generation_index": { "type": "integer" },
-          "y_order": { "type": "integer" },
-          "status": { "enum": ["launching", "running", "draining", "closed", "failed"] }
-        }
-      }
-    },
-    "headless_workers": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "required": ["slot_id", "generation_index", "reason"],
-        "properties": {
-          "slot_id": { "type": "string" },
-          "generation_index": { "type": "integer" },
-          "reason": { "type": "string" }
-        }
-      }
-    },
-    "blockers": { "type": "array", "items": { "type": "string" } }
-  }
-}

package/schemas/zellij/zellij-slot-telemetry.schema.json

@@ -1,89 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "sks.zellij-slot-telemetry.v1",
-  "title": "SKS Zellij Slot Telemetry",
-  "oneOf": [
-    { "$ref": "#/$defs/event" },
-    { "$ref": "#/$defs/snapshot" }
-  ],
-  "$defs": {
-    "event": {
-      "type": "object",
-      "required": ["schema", "ts", "mission_id", "slot_id", "generation_index", "worker_id", "event_type", "status"],
-      "properties": {
-        "schema": { "const": "sks.zellij-slot-telemetry-event.v1" },
-        "ts": { "type": "string" },
-        "mission_id": { "type": "string" },
-        "slot_id": { "type": "string" },
-        "generation_index": { "type": "integer", "minimum": 1 },
-        "worker_id": { "type": "string" },
-        "event_type": {
-          "enum": [
-            "slot_reserved",
-            "worker_spawned",
-            "heartbeat",
-            "task_started",
-            "task_progress",
-            "artifact_written",
-            "patch_candidate",
-            "verification_started",
-            "verification_passed",
-            "verification_failed",
-            "worker_completed",
-            "worker_failed",
-            "headless_overflow"
-          ]
-        },
-        "status": {
-          "enum": ["queued", "launching", "running", "verifying", "completed", "failed", "headless", "drained"]
-        },
-        "role": { "type": "string" },
-        "backend": { "type": "string" },
-        "provider": { "type": "string" },
-        "service_tier": { "type": "string" },
-        "worktree_id": { "type": ["string", "null"] },
-        "worktree_path": { "type": ["string", "null"] },
-        "task_title": { "type": "string" },
-        "current_file": { "type": ["string", "null"] },
-        "progress": {
-          "type": "object",
-          "required": ["done", "total", "label"],
-          "properties": {
-            "done": { "type": "integer", "minimum": 0 },
-            "total": { "type": "integer", "minimum": 0 },
-            "label": { "type": "string" }
-          },
-          "additionalProperties": false
-        },
-        "artifact_paths": { "type": "array", "items": { "type": "string" } },
-        "log_tail": { "type": "string" },
-        "blockers": { "type": "array", "items": { "type": "string" } }
-      },
-      "additionalProperties": false
-    },
-    "snapshot": {
-      "type": "object",
-      "required": ["schema", "mission_id", "updated_at", "slots", "counts"],
-      "properties": {
-        "schema": { "const": "sks.zellij-slot-telemetry-snapshot.v1" },
-        "mission_id": { "type": "string" },
-        "updated_at": { "type": "string" },
-        "slots": { "type": "object" },
-        "counts": {
-          "type": "object",
-          "required": ["queued", "running", "verifying", "completed", "failed", "headless"],
-          "properties": {
-            "queued": { "type": "integer", "minimum": 0 },
-            "running": { "type": "integer", "minimum": 0 },
-            "verifying": { "type": "integer", "minimum": 0 },
-            "completed": { "type": "integer", "minimum": 0 },
-            "failed": { "type": "integer", "minimum": 0 },
-            "headless": { "type": "integer", "minimum": 0 }
-          },
-          "additionalProperties": false
-        }
-      },
-      "additionalProperties": false
-    }
-  }
-}

package/schemas/zellij/zellij-worker-pane.schema.json

@@ -1,53 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://sneakoscope.local/schemas/zellij/zellij-worker-pane.schema.json",
-  "title": "SKS Zellij Worker Pane",
-  "type": "object",
-  "required": [
-    "schema",
-    "ok",
-    "status",
-    "session_name",
-    "slot_id",
-    "generation_index",
-    "session_id",
-    "pane_name",
-    "pane_kind",
-    "pane_id",
-    "pane_id_source",
-    "worker_artifact_dir",
-    "worker_result_path",
-    "heartbeat_path",
-    "parent_child_transport",
-    "scaling_primitive",
-    "blockers"
-  ],
-  "properties": {
-    "schema": { "const": "sks.zellij-worker-pane.v1" },
-    "ok": { "type": "boolean" },
-    "status": { "enum": ["launching", "running", "closed", "failed"] },
-    "session_name": { "type": "string", "minLength": 1 },
-    "slot_id": { "type": "string", "pattern": "^slot-[0-9]{3}$" },
-    "generation_index": { "type": "integer", "minimum": 1 },
-    "session_id": { "type": "string", "minLength": 1 },
-    "pane_name": { "type": "string", "pattern": "^slot-[0-9]{3}/gen-[0-9]+$" },
-    "pane_kind": { "const": "worker_codex_cli" },
-    "pane_id": { "type": ["string", "null"] },
-    "pane_id_source": {
-      "enum": [
-        "zellij_worker_new_pane_stdout",
-        "zellij_worker_list_panes",
-        "zellij_worker_pane_stdout_missing",
-        "zellij_worker_pane_launch_failed"
-      ]
-    },
-    "worker_artifact_dir": { "type": "string", "minLength": 1 },
-    "worker_result_path": { "type": "string", "minLength": 1 },
-    "heartbeat_path": { "type": "string", "minLength": 1 },
-    "patch_envelope_path": { "type": "string" },
-    "parent_child_transport": { "const": "worker-result-json-and-heartbeat" },
-    "scaling_primitive": { "const": "native_cli_process_in_zellij_worker_pane" },
-    "blockers": { "type": "array", "items": { "type": "string" } }
-  },
-  "additionalProperties": true
-}

package/scripts/build-clean-atomic.mjs

@@ -1,323 +0,0 @@
-#!/usr/bin/env node
-import { spawn, spawnSync } from 'node:child_process';
-import { randomBytes } from 'node:crypto';
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const modulePath = fileURLToPath(import.meta.url);
-const root = path.resolve(path.dirname(modulePath), '..');
-const ATOMIC_BUILD_LOCK_SCHEMA = 'sks.atomic-build-lock.v1';
-const CORRUPT_LOCK_GRACE_MS = 120_000;
-
-export async function buildCleanAtomic() {
-  const cacheRoot = path.join(root, '.sneakoscope', 'cache', 'atomic-build');
-  const liveDist = path.join(root, 'dist');
-  const lock = await acquireAtomicBuildLock({ cacheRoot });
-  try {
-    await recoverInterruptedAtomicBuild({ cacheRoot, liveDist });
-    const buildId = `${Date.now()}-${process.pid}-${randomBytes(4).toString('hex')}`;
-    const stageParent = path.join(cacheRoot, buildId);
-    const stageDist = path.join(stageParent, 'dist');
-    const backupDist = path.join(stageParent, 'previous-dist');
-    const buildInfo = path.join(stageParent, 'tsconfig.build.tsbuildinfo');
-    const tsc = path.join(root, 'node_modules', 'typescript', 'bin', 'tsc');
-    const buildEnvironment = {
-      ...process.env,
-      SKS_BUILD_SOURCE_ROOT: root,
-      SKS_BUILD_OUTPUT_DIR: stageDist
-    };
-
-    let liveMoved = false;
-    let preserveRecovery = false;
-    try {
-      await fsp.mkdir(stageParent, { recursive: true });
-      await run(process.execPath, [
-        tsc,
-        '-p',
-        path.join(root, 'tsconfig.build.json'),
-        '--outDir',
-        stageDist,
-        '--tsBuildInfoFile',
-        buildInfo
-      ], process.env);
-      await run(
-        process.execPath,
-        [path.join(stageDist, 'scripts', 'ensure-bin-executable.js')],
-        buildEnvironment
-      );
-      await run(
-        process.execPath,
-        [path.join(stageDist, 'scripts', 'build-dist.js')],
-        buildEnvironment
-      );
-      await Promise.all([
-        fsp.access(path.join(stageDist, 'bin', 'sks.js')),
-        fsp.access(path.join(stageDist, 'config', 'skills-manifest.json')),
-        fsp.access(path.join(stageDist, '.sks-build-stamp.json'))
-      ]);
-
-      try {
-        await fsp.rename(liveDist, backupDist);
-        liveMoved = true;
-      } catch (error) {
-        if (error?.code !== 'ENOENT') throw error;
-      }
-      try {
-        await fsp.rename(stageDist, liveDist);
-      } catch (error) {
-        if (liveMoved) {
-          try {
-            await restorePreviousDistAfterFailedPromotion({
-              backupDist,
-              liveDist,
-              promotionError: error
-            });
-            liveMoved = false;
-          } catch (combinedError) {
-            preserveRecovery = true;
-            throw combinedError;
-          }
-        }
-        throw error;
-      }
-      const reportStamp = path.join(root, '.sneakoscope', 'reports', 'dist-build-stamp.json');
-      await fsp.mkdir(path.dirname(reportStamp), { recursive: true });
-      await fsp.copyFile(path.join(liveDist, '.sks-build-stamp.json'), reportStamp);
-      if (liveMoved) {
-        await fsp.rm(backupDist, { recursive: true, force: true });
-        liveMoved = false;
-      }
-    } finally {
-      if (liveMoved && !preserveRecovery) {
-        const liveExists = await pathExists(liveDist);
-        if (!liveExists) {
-          try {
-            await fsp.rename(backupDist, liveDist);
-            liveMoved = false;
-          } catch (restoreError) {
-            preserveRecovery = true;
-            console.error(
-              `atomic_build_restore_failed:recovery_preserved:${backupDist}:${
-                String(restoreError?.message || restoreError)
-              }`
-            );
-          }
-        } else {
-          // A post-promotion step failed. Keep the previous generation
-          // available for explicit or next-start recovery.
-          preserveRecovery = true;
-        }
-      }
-      if (!preserveRecovery) {
-        await fsp.rm(stageParent, { recursive: true, force: true }).catch(() => undefined);
-      }
-    }
-  } finally {
-    await lock.release();
-  }
-}
-
-export async function recoverInterruptedAtomicBuild({
-  cacheRoot,
-  liveDist,
-  fsApi = fsp
-}) {
-  if (await pathExists(liveDist, fsApi)) return { recovered: false, source: null };
-  let entries;
-  try {
-    entries = await fsApi.readdir(cacheRoot, { withFileTypes: true });
-  } catch (error) {
-    if (error?.code === 'ENOENT') return { recovered: false, source: null };
-    throw error;
-  }
-  const candidates = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
-    const candidate = path.join(cacheRoot, entry.name, 'previous-dist');
-    try {
-      const stat = await fsApi.lstat(candidate);
-      if (stat.isDirectory() && !stat.isSymbolicLink()) {
-        candidates.push({ candidate, mtimeMs: stat.mtimeMs });
-      }
-    } catch (error) {
-      if (error?.code !== 'ENOENT') throw error;
-    }
-  }
-  candidates.sort((left, right) => right.mtimeMs - left.mtimeMs);
-  const selected = candidates[0]?.candidate || null;
-  if (!selected) return { recovered: false, source: null };
-  await fsApi.rename(selected, liveDist);
-  return { recovered: true, source: selected };
-}
-
-export async function acquireAtomicBuildLock({
-  cacheRoot,
-  fsApi = fsp,
-  heartbeatMs = 5_000
-}) {
-  const lockPath = path.join(path.resolve(cacheRoot), '.build.lock');
-  await fsApi.mkdir(path.dirname(lockPath), { recursive: true });
-  const token = `${process.pid}-${Date.now()}-${randomBytes(8).toString('hex')}`;
-  const owner = {
-    schema: ATOMIC_BUILD_LOCK_SCHEMA,
-    token,
-    pid: process.pid,
-    process_start: processStartIdentity(process.pid),
-    acquired_at: new Date().toISOString(),
-    heartbeat_at: new Date().toISOString()
-  };
-  let acquired = false;
-  for (let attempt = 0; attempt < 2 && !acquired; attempt += 1) {
-    let createdLock = false;
-    try {
-      await fsApi.mkdir(lockPath);
-      createdLock = true;
-      await writeAtomicBuildLockOwner(lockPath, owner, fsApi);
-      acquired = true;
-    } catch (error) {
-      if (createdLock) {
-        await fsApi.rm(lockPath, { recursive: true, force: true }).catch(() => undefined);
-      }
-      if (error?.code !== 'EEXIST') throw error;
-      if (attempt > 0 || !await reclaimStaleAtomicBuildLock(lockPath, fsApi)) {
-        throw new Error(`atomic_build_already_running:${lockPath}`);
-      }
-    }
-  }
-  if (!acquired) throw new Error(`atomic_build_already_running:${lockPath}`);
-  const heartbeat = setInterval(() => {
-    owner.heartbeat_at = new Date().toISOString();
-    writeAtomicBuildLockOwner(lockPath, owner, fsApi).catch(() => undefined);
-  }, Math.max(250, heartbeatMs));
-  if (typeof heartbeat.unref === 'function') heartbeat.unref();
-  let released = false;
-  return {
-    lockPath,
-    token,
-    async release() {
-      if (released) return;
-      released = true;
-      clearInterval(heartbeat);
-      const current = await readAtomicBuildLockOwner(lockPath, fsApi);
-      if (current?.token !== token) return;
-      const claimed = `${lockPath}.release-${token}`;
-      try {
-        await fsApi.rename(lockPath, claimed);
-      } catch (error) {
-        if (error?.code === 'ENOENT') return;
-        throw error;
-      }
-      await fsApi.rm(claimed, { recursive: true, force: true });
-    }
-  };
-}
-
-async function reclaimStaleAtomicBuildLock(lockPath, fsApi) {
-  const current = await readAtomicBuildLockOwner(lockPath, fsApi);
-  let stale = false;
-  if (current?.schema === ATOMIC_BUILD_LOCK_SCHEMA
-    && Number.isSafeInteger(current.pid)
-    && current.pid > 0) {
-    stale = !processIdentityAlive(current.pid, current.process_start);
-  } else {
-    try {
-      const stat = await fsApi.stat(lockPath);
-      stale = Date.now() - stat.mtimeMs > CORRUPT_LOCK_GRACE_MS;
-    } catch {
-      return true;
-    }
-  }
-  if (!stale) return false;
-  const claimed = `${lockPath}.stale-${Date.now()}-${randomBytes(4).toString('hex')}`;
-  try {
-    await fsApi.rename(lockPath, claimed);
-  } catch {
-    return false;
-  }
-  await fsApi.rm(claimed, { recursive: true, force: true }).catch(() => undefined);
-  return true;
-}
-
-async function writeAtomicBuildLockOwner(lockPath, owner, fsApi) {
-  const file = path.join(lockPath, 'owner.json');
-  const tmp = `${file}.${owner.token}.tmp`;
-  try {
-    await fsApi.writeFile(tmp, `${JSON.stringify(owner)}\n`, { mode: 0o600 });
-    await fsApi.rename(tmp, file);
-  } finally {
-    await fsApi.rm(tmp, { force: true }).catch(() => undefined);
-  }
-}
-
-async function readAtomicBuildLockOwner(lockPath, fsApi) {
-  try {
-    return JSON.parse(await fsApi.readFile(path.join(lockPath, 'owner.json'), 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function processIdentityAlive(pid, expectedStart) {
-  try {
-    process.kill(pid, 0);
-  } catch (error) {
-    return error?.code !== 'ESRCH';
-  }
-  if (!expectedStart) return true;
-  const observed = processStartIdentity(pid);
-  return observed === null || observed === expectedStart;
-}
-
-function processStartIdentity(pid) {
-  const result = spawnSync('/bin/ps', ['-o', 'lstart=', '-p', String(pid)], {
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'ignore']
-  });
-  if (result.status !== 0) return null;
-  return String(result.stdout || '').trim() || null;
-}
-
-async function pathExists(target, fsApi = fsp) {
-  try {
-    await fsApi.access(target);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function restorePreviousDistAfterFailedPromotion({
-  backupDist,
-  liveDist,
-  promotionError,
-  fsApi = fsp
-}) {
-  try {
-    await fsApi.rename(backupDist, liveDist);
-  } catch (restoreError) {
-    throw new AggregateError(
-      [promotionError, restoreError],
-      `atomic_build_promotion_and_restore_failed:recovery_preserved:${backupDist}`
-    );
-  }
-}
-
-async function run(command, args, env) {
-  await new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      cwd: root,
-      env,
-      stdio: 'inherit'
-    });
-    child.once('error', reject);
-    child.once('exit', (code, signal) => {
-      if (code === 0) resolve();
-      else reject(new Error(`atomic_build_step_failed:${path.basename(args[0] || command)}:${code ?? signal}`));
-    });
-  });
-}
-
-if (process.argv[1] && path.resolve(process.argv[1]) === modulePath) {
-  await buildCleanAtomic();
-}