@minionry/minion 0.7.36

package/dist/server/services/git/status-ops.js

@@ -0,0 +1,105 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { resolve } from 'node:path';
+import { executeGitCommand, gitErrorText } from './command.js';
+import { parseAheadBehind, parseGitStatus } from './parsers.js';
+import { gitFail, gitOk } from './types.js';
+export async function readStatus({ cwd }) {
+    const statusResult = await executeGitCommand(['status', '--porcelain=v1'], cwd);
+    if (statusResult.exitCode !== 0) {
+        return gitFail(gitErrorText(statusResult, 'Failed to get git status'));
+    }
+    const branchResult = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+    const branch = branchResult.stdout.trim() || 'HEAD';
+    let ahead = 0;
+    let behind = 0;
+    let hasUpstream = false;
+    const trackingResult = await executeGitCommand(['rev-list', '--left-right', '--count', `${branch}...@{u}`], cwd);
+    if (trackingResult.exitCode === 0) {
+        hasUpstream = true;
+        ({ ahead, behind } = parseAheadBehind(trackingResult.stdout));
+    }
+    else {
+        const localResult = await executeGitCommand(['rev-list', '--count', 'HEAD'], cwd);
+        if (localResult.exitCode === 0) {
+            ahead = parseInt(localResult.stdout.trim(), 10) || 0;
+        }
+    }
+    const { staged, unstaged, untracked } = parseGitStatus(statusResult.stdout);
+    return gitOk({
+        status: {
+            branch,
+            isDirty: staged.length > 0 || unstaged.length > 0 || untracked.length > 0,
+            staged,
+            unstaged,
+            untracked,
+            ahead,
+            behind,
+            hasUpstream,
+        },
+        porcelain: statusResult.stdout,
+    });
+}
+export async function readHeadSha({ cwd }) {
+    const result = await executeGitCommand(['rev-parse', 'HEAD'], cwd);
+    return result.exitCode === 0 ? result.stdout.trim() : null;
+}
+export async function stagePaths({ cwd, stageAll, paths }) {
+    if (!stageAll && (!paths || paths.length === 0)) {
+        return gitFail('No paths specified for staging');
+    }
+    if (!stageAll && paths) {
+        const resolvedRoot = resolve(cwd);
+        for (const p of paths) {
+            if (!resolve(cwd, p).startsWith(resolvedRoot)) {
+                return gitFail(`Path traversal not allowed: ${p}`);
+            }
+        }
+    }
+    const args = stageAll ? ['add', '-A'] : ['add', '--', ...paths];
+    const result = await executeGitCommand(args, cwd);
+    if (result.exitCode !== 0) {
+        return gitFail(gitErrorText(result, 'Failed to stage files'));
+    }
+    return gitOk({ paths: paths || [] });
+}
+export async function unstagePaths({ cwd, paths }) {
+    const result = await executeGitCommand(['reset', 'HEAD', '--', ...paths], cwd);
+    if (result.exitCode !== 0) {
+        return gitFail(gitErrorText(result, 'Failed to unstage files'));
+    }
+    return gitOk({ paths });
+}
+export const MAX_COMMIT_MESSAGE_LENGTH = 10_000;
+export async function commit({ cwd, message }) {
+    const result = await executeGitCommand(['commit', '-m', message], cwd);
+    if (result.exitCode !== 0) {
+        const error = gitErrorText(result, 'Failed to commit');
+        return {
+            ok: false,
+            error,
+            nothingToCommit: error.includes('nothing to commit') || error.includes('no changes added'),
+        };
+    }
+    const hashResult = await executeGitCommand(['rev-parse', '--short', 'HEAD'], cwd);
+    return { ok: true, hash: hashResult.stdout.trim() };
+}
+export async function push({ cwd }) {
+    const branchResult = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+    const branch = branchResult.stdout.trim();
+    const upstreamCheck = await executeGitCommand(['rev-parse', '--abbrev-ref', `${branch}@{u}`], cwd);
+    const hasUpstream = upstreamCheck.exitCode === 0;
+    const pushArgs = hasUpstream ? ['push'] : ['push', '-u', 'origin', branch];
+    const result = await executeGitCommand(pushArgs, cwd);
+    if (result.exitCode !== 0) {
+        return gitFail(gitErrorText(result, 'Failed to push'));
+    }
+    return gitOk({ output: result.stdout || result.stderr });
+}
+export async function pull({ cwd }) {
+    const result = await executeGitCommand(['pull'], cwd);
+    if (result.exitCode !== 0) {
+        return gitFail(gitErrorText(result, 'Failed to pull'));
+    }
+    return gitOk({ output: result.stdout || result.stderr });
+}

package/dist/server/services/git/suggestion-ops.js

@@ -0,0 +1,80 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { createHash } from 'node:crypto';
+import { executeGitCommand } from './command.js';
+import { buildCommitMessagePrompt, COMMIT_MESSAGE_SYSTEM_PROMPT, classifyCommitMessageFailure, runHaikuForCommitMessage, } from './commit-message.js';
+import { logCommitMessageEvent, truncateDiff } from './haiku.js';
+import { discoverRepos } from './log-ops.js';
+import { parseGitStatus } from './parsers.js';
+const GIT_TIMEOUT_MS = 15_000;
+const MAX_GIT_OUTPUT_BYTES = 5_000_000;
+export const GIT_VIEW_TAB_ID = 'gitview';
+export function computeStatusKey(headSha, porcelainStatus) {
+    return createHash('sha1').update(headSha).update('\0').update(porcelainStatus).digest('hex');
+}
+export async function resolveSuggestionRepoRoots(dir) {
+    const guard = { timeoutMs: GIT_TIMEOUT_MS, maxOutputBytes: MAX_GIT_OUTPUT_BYTES };
+    const toplevel = await executeGitCommand(['rev-parse', '--show-toplevel'], dir, guard);
+    if (toplevel.exitCode === 0) {
+        const root = toplevel.stdout.trim();
+        return root ? [root] : [];
+    }
+    const { repos } = await discoverRepos({ cwd: dir });
+    return repos.map((repo) => repo.path);
+}
+export async function snapshotWorktree(dir) {
+    const guard = { timeoutMs: GIT_TIMEOUT_MS, maxOutputBytes: MAX_GIT_OUTPUT_BYTES };
+    const status = await executeGitCommand(['status', '--porcelain=v1'], dir, guard);
+    if (status.exitCode !== 0)
+        return null;
+    const head = await executeGitCommand(['rev-parse', 'HEAD'], dir, guard);
+    if (head.exitCode !== 0)
+        return null;
+    const headSha = head.stdout.trim();
+    const statusKey = computeStatusKey(headSha, status.stdout);
+    const { staged, unstaged, untracked } = parseGitStatus(status.stdout);
+    if (staged.length === 0 && unstaged.length === 0 && untracked.length === 0) {
+        return { statusKey, branch: '', isDirty: false, diff: '', filesList: '', recentCommits: '' };
+    }
+    const branchRes = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], dir, guard);
+    const diffRes = await executeGitCommand(['diff', 'HEAD'], dir, guard);
+    if (diffRes.exitCode !== 0)
+        return null;
+    const logRes = await executeGitCommand(['log', '--oneline', '-5'], dir, guard);
+    const seen = new Set();
+    const fileLines = [];
+    for (const file of [...staged, ...unstaged, ...untracked]) {
+        if (seen.has(file.path))
+            continue;
+        seen.add(file.path);
+        fileLines.push(`${file.status} ${file.path}`);
+    }
+    const untrackedAppendix = untracked.length > 0
+        ? `\n\nUNTRACKED FILES (new files that would be added):\n${untracked.map((f) => f.path).join('\n')}`
+        : '';
+    return {
+        statusKey,
+        branch: branchRes.stdout.trim() || 'HEAD',
+        isDirty: true,
+        diff: diffRes.stdout + untrackedAppendix,
+        filesList: fileLines.join('\n'),
+        recentCommits: logRes.stdout.trim() || 'No recent commits',
+    };
+}
+export async function generateSuggestionMessage(dir, snapshot) {
+    const startedAt = Date.now();
+    const diffBytes = snapshot.diff.length;
+    const prompt = buildCommitMessagePrompt(dir, {
+        recentCommits: snapshot.recentCommits,
+        stagedFiles: snapshot.filesList,
+        diff: truncateDiff(snapshot.diff),
+    });
+    const { result, attempts, message } = await runHaikuForCommitMessage(prompt, COMMIT_MESSAGE_SYSTEM_PROMPT, dir, { tabId: GIT_VIEW_TAB_ID, startedAt, diffBytes });
+    logCommitMessageEvent(dir, {
+        tabId: GIT_VIEW_TAB_ID, source: 'auto-suggest', attempt: attempts,
+        success: message.length > 0,
+        latencyMs: Date.now() - startedAt, diffBytes, messageLength: message.length,
+        ...(message ? {} : { reason: classifyCommitMessageFailure(result).reason, exitCode: result.exitCode, timedOut: result.timedOut }),
+    });
+    return message;
+}

package/dist/server/services/git/tag-ops.js

@@ -0,0 +1,36 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { executeGitCommand } from './command.js';
+import { parseTagList, TAG_LIST_FORMAT } from './parsers.js';
+import { gitFail, gitOk } from './types.js';
+export async function listTags({ cwd }) {
+    const result = await executeGitCommand(['tag', '-l', '--sort=-creatordate', `--format=${TAG_LIST_FORMAT}`], cwd);
+    if (result.exitCode !== 0) {
+        return gitFail(result.stderr || 'Failed to list tags');
+    }
+    return gitOk(parseTagList(result.stdout));
+}
+export async function createTag({ cwd, name, message, commit }) {
+    if (/\s/.test(name) || name.includes('..')) {
+        return gitFail('Invalid tag name: no spaces or ".." allowed');
+    }
+    const args = message
+        ? ['tag', '-a', name, '-m', message, ...(commit ? [commit] : [])]
+        : ['tag', name, ...(commit ? [commit] : [])];
+    const result = await executeGitCommand(args, cwd);
+    if (result.exitCode !== 0) {
+        return gitFail(result.stderr || 'Failed to create tag');
+    }
+    const hashResult = await executeGitCommand(['rev-parse', '--short', name], cwd);
+    return gitOk({ name, hash: hashResult.stdout.trim() });
+}
+export async function pushTag({ cwd, name, all }) {
+    const args = all
+        ? ['push', 'origin', '--tags']
+        : ['push', 'origin', name];
+    const result = await executeGitCommand(args, cwd);
+    if (result.exitCode !== 0) {
+        return gitFail(result.stderr || 'Failed to push tag');
+    }
+    return gitOk({ output: result.stderr || result.stdout });
+}

package/dist/server/services/git/types.js

@@ -0,0 +1,4 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export const gitOk = (value) => ({ ok: true, value });
+export const gitFail = (error) => ({ ok: false, error });

package/dist/server/services/git/worktree-ops.js

@@ -0,0 +1,114 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { executeGitCommand, spawnWithOutput } from './command.js';
+import { deriveWorktreePath, firstWorktreePath, parseWorktreePorcelain, parseWorktreeStatusSummary } from './parsers.js';
+import { gitFail, gitOk } from './types.js';
+export async function readCurrentBranch(dir) {
+    const result = await executeGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], dir);
+    return result.stdout.trim();
+}
+export async function isInsideGitRepo(dir) {
+    const result = await executeGitCommand(['rev-parse', '--show-toplevel'], dir);
+    return result.exitCode === 0;
+}
+export async function resolveMainWorktreeRoot(dir) {
+    const result = await executeGitCommand(['worktree', 'list', '--porcelain'], dir);
+    if (result.exitCode !== 0)
+        return dir;
+    return parseWorktreePorcelain(result.stdout).find((wt) => wt.isMain)?.path || dir;
+}
+export async function resolveMainWorktreePath(dir) {
+    const wtListResult = await executeGitCommand(['worktree', 'list', '--porcelain'], dir);
+    return firstWorktreePath(wtListResult.stdout) ?? dir;
+}
+async function attachWorktreeStatuses(worktrees) {
+    await Promise.all(worktrees.map(async (wt) => {
+        if (wt.isBare)
+            return;
+        const result = await executeGitCommand(['--no-optional-locks', 'status', '--porcelain=v2', '--branch'], wt.path, { timeoutMs: 8000, maxOutputBytes: 2_000_000 });
+        if (result.exitCode !== 0)
+            return;
+        wt.status = parseWorktreeStatusSummary(result.stdout);
+    }));
+}
+export async function listWorktrees({ cwd, includeStatus }) {
+    const result = await executeGitCommand(['worktree', 'list', '--porcelain'], cwd);
+    if (result.exitCode !== 0) {
+        return gitFail(result.stderr || 'Failed to list worktrees');
+    }
+    const worktrees = parseWorktreePorcelain(result.stdout);
+    if (includeStatus) {
+        await attachWorktreeStatuses(worktrees);
+    }
+    return gitOk(worktrees);
+}
+export async function createWorktree({ cwd, branchName, baseBranch, path }) {
+    const baseDir = await resolveMainWorktreeRoot(cwd);
+    const wtPath = path || deriveWorktreePath(baseDir, branchName);
+    const args = ['worktree', 'add', wtPath, '-b', branchName, ...(baseBranch ? [baseBranch] : [])];
+    const result = await executeGitCommand(args, baseDir);
+    if (result.exitCode !== 0) {
+        return gitFail(result.stderr || 'Failed to create worktree');
+    }
+    const headResult = await executeGitCommand(['rev-parse', '--short', 'HEAD'], wtPath);
+    return gitOk({ path: wtPath, branch: branchName, head: headResult.stdout.trim() });
+}
+export async function removeWorktree({ cwd, path, force, deleteBranch }) {
+    let branchToDelete;
+    if (deleteBranch) {
+        branchToDelete = await readCurrentBranch(path);
+    }
+    const args = force ? ['worktree', 'remove', '--force', path] : ['worktree', 'remove', path];
+    const result = await executeGitCommand(args, cwd);
+    if (result.exitCode !== 0) {
+        return gitFail(result.stderr || 'Failed to remove worktree');
+    }
+    if (branchToDelete && deleteBranch) {
+        await executeGitCommand(['branch', '-d', branchToDelete], cwd);
+    }
+    await executeGitCommand(['worktree', 'prune'], cwd);
+    return gitOk({ path });
+}
+async function pushWithUpstreamRetry(worktreePath, pushRemote, pushBranch, setUpstream) {
+    const args = setUpstream
+        ? ['push', '--set-upstream', pushRemote, pushBranch]
+        : ['push', pushRemote, pushBranch];
+    const result = await executeGitCommand(args, worktreePath);
+    if (result.exitCode === 0)
+        return { exitCode: 0, output: result.stderr || result.stdout, error: '' };
+    const needsUpstream = result.stderr.includes('no upstream') || result.stderr.includes('has no upstream');
+    if (!needsUpstream)
+        return { exitCode: result.exitCode, output: '', error: result.stderr || 'Failed to push' };
+    const retry = await executeGitCommand(['push', '--set-upstream', pushRemote, pushBranch], worktreePath);
+    if (retry.exitCode !== 0)
+        return { exitCode: retry.exitCode, output: '', error: retry.stderr || 'Failed to push' };
+    return { exitCode: 0, output: retry.stderr || retry.stdout, error: '' };
+}
+export async function pushWorktree({ cwd, remote, branch, setUpstream }) {
+    const pushRemote = remote || 'origin';
+    const currentBranch = await readCurrentBranch(cwd);
+    const pushBranch = branch || currentBranch;
+    const pushResult = await pushWithUpstreamRetry(cwd, pushRemote, pushBranch, !!setUpstream);
+    if (pushResult.exitCode !== 0) {
+        return gitFail(pushResult.error);
+    }
+    return gitOk({ output: pushResult.output, upstream: `${pushRemote}/${pushBranch}` });
+}
+export async function createWorktreePr({ cwd, title, body, baseBranch, draft }) {
+    const branchName = await readCurrentBranch(cwd);
+    const prTitle = title || branchName.replace(/[-_/]/g, ' ').replace(/^\w/, c => c.toUpperCase());
+    const args = ['pr', 'create', '--title', prTitle];
+    if (body)
+        args.push('--body', body);
+    if (baseBranch)
+        args.push('--base', baseBranch);
+    if (draft)
+        args.push('--draft');
+    const result = await spawnWithOutput('gh', args, cwd);
+    if (result.exitCode !== 0) {
+        return gitFail(result.stderr || 'Failed to create PR');
+    }
+    const prUrl = result.stdout.trim();
+    const prNumberMatch = prUrl.match(/\/(\d+)$/);
+    return gitOk({ prUrl, prNumber: prNumberMatch ? parseInt(prNumberMatch[1], 10) : 0 });
+}

package/dist/server/services/instances.js

@@ -0,0 +1,337 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, realpathSync, rmSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { delimiter, join, resolve } from 'node:path';
+import { ensureMachineDir, machineFile, machineLockPath, machinePath } from '../../bin/machine-layout.js';
+import { withFileLock, writeFileAtomic } from '../utils/file-store.js';
+import { MINIONRY_ROOT } from '../utils/paths.js';
+import { resolveCliEnvironment } from './platform-url.js';
+const instancesLockPath = () => machineLockPath('instances');
+function normalizeDirIdentity(dir) {
+    try {
+        return realpathSync(resolve(dir));
+    }
+    catch {
+        return resolve(dir);
+    }
+}
+function defaultIsPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === 'EPERM';
+    }
+}
+export function pickLiveDuplicate(instances, workingDirectory, environment, options = {}) {
+    const { selfPid = process.pid, isPidAlive = defaultIsPidAlive, ignorePids = [] } = options;
+    const targetDir = normalizeDirIdentity(workingDirectory);
+    const isRival = (instance) => instance.pid !== selfPid &&
+        !ignorePids.includes(instance.pid) &&
+        (instance.environment ?? 'production') === environment &&
+        normalizeDirIdentity(instance.workingDirectory) === targetDir &&
+        isPidAlive(instance.pid);
+    const registeredEarlier = (a, b) => a.startedAt < b.startedAt || (a.startedAt === b.startedAt && a.pid < b.pid);
+    let duplicate = null;
+    for (const instance of instances) {
+        if (!isRival(instance))
+            continue;
+        if (duplicate === null || registeredEarlier(instance, duplicate))
+            duplicate = instance;
+    }
+    return duplicate;
+}
+export async function probeInstanceIdentity(port, timeoutMs = 1500) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/health`, { signal: controller.signal });
+        if (!res.ok)
+            return { alive: false };
+        const body = (await res.json());
+        if (body.status !== 'ok')
+            return { alive: false };
+        return {
+            alive: true,
+            workingDirectory: typeof body.workingDirectory === 'string' ? body.workingDirectory : undefined,
+            environment: typeof body.environment === 'string' ? body.environment : undefined,
+            pid: typeof body.pid === 'number' ? body.pid : undefined,
+        };
+    }
+    catch {
+        return { alive: false };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function probeInstanceHealth(port, timeoutMs = 1500) {
+    return (await probeInstanceIdentity(port, timeoutMs)).alive;
+}
+export function identityMatchesSpace(identity, workingDirectory, environment) {
+    if (!identity.alive)
+        return false;
+    if (!identity.workingDirectory || !identity.environment)
+        return false;
+    return (normalizeDirIdentity(identity.workingDirectory) === normalizeDirIdentity(workingDirectory) &&
+        identity.environment === environment);
+}
+export function parseSupersededPids(raw) {
+    if (!raw)
+        return [];
+    return raw
+        .split(',')
+        .map((s) => Number.parseInt(s.trim(), 10))
+        .filter((pid) => Number.isInteger(pid) && pid > 0);
+}
+export class InstanceRegistry {
+    registryPath;
+    currentInstance = null;
+    heartbeatInterval = null;
+    constructor() {
+        ensureMachineDir('state');
+        this.registryPath = machineFile('instances');
+    }
+    register(port, workingDirectory) {
+        const instance = {
+            id: `minionry-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
+            port,
+            url: `http://localhost:${port}`,
+            workingDirectory,
+            startedAt: Date.now(),
+            lastHeartbeat: Date.now(),
+            pid: process.pid,
+            environment: resolveCliEnvironment()
+        };
+        this.currentInstance = instance;
+        this.saveInstance(instance);
+        this.startHeartbeat();
+        return instance;
+    }
+    unregister() {
+        if (this.currentInstance) {
+            this.removeInstance(this.currentInstance.id);
+            this.currentInstance = null;
+        }
+        this.stopHeartbeat();
+    }
+    getCurrentInstance() {
+        return this.currentInstance;
+    }
+    static getAllInstances() {
+        const registryPath = machineFile('instances');
+        if (!existsSync(registryPath)) {
+            return [];
+        }
+        return withFileLock(instancesLockPath(), () => {
+            try {
+                const data = readFileSync(registryPath, 'utf-8');
+                if (!data?.trim()) {
+                    return [];
+                }
+                const parsed = JSON.parse(data);
+                const instances = Array.isArray(parsed) ? parsed : [];
+                const now = Date.now();
+                const maxAge = 2 * 60 * 1000;
+                return instances.filter(instance => now - instance.lastHeartbeat < maxAge);
+            }
+            catch (error) {
+                if (error instanceof SyntaxError) {
+                    console.warn('[InstanceRegistry] Registry file corrupted, will be recreated on next write');
+                }
+                else {
+                    console.error('[InstanceRegistry] Failed to read instances registry:', error);
+                }
+                return [];
+            }
+        }, { timeoutMs: 3000 });
+    }
+    static getInstance(id) {
+        const instances = InstanceRegistry.getAllInstances();
+        return instances.find(i => i.id === id) || null;
+    }
+    static findLiveDuplicate(workingDirectory, environment, options = {}) {
+        return pickLiveDuplicate(InstanceRegistry.getAllInstances(), workingDirectory, environment, options);
+    }
+    saveInstance(instance) {
+        withFileLock(instancesLockPath(), () => {
+            let instances = [];
+            if (existsSync(this.registryPath)) {
+                try {
+                    const data = readFileSync(this.registryPath, 'utf-8');
+                    if (data?.trim()) {
+                        const parsed = JSON.parse(data);
+                        instances = Array.isArray(parsed) ? parsed : [];
+                    }
+                }
+                catch {
+                    instances = [];
+                }
+            }
+            const now = Date.now();
+            const maxAge = 2 * 60 * 1000;
+            instances = instances.filter(i => i.id !== instance.id && now - i.lastHeartbeat < maxAge);
+            instances.push(instance);
+            writeFileAtomic(this.registryPath, JSON.stringify(instances, null, 2), { mode: 0o644 });
+        });
+    }
+    removeInstance(id) {
+        withFileLock(instancesLockPath(), () => {
+            let instances = [];
+            if (existsSync(this.registryPath)) {
+                try {
+                    const data = readFileSync(this.registryPath, 'utf-8');
+                    if (data?.trim()) {
+                        const parsed = JSON.parse(data);
+                        instances = Array.isArray(parsed) ? parsed : [];
+                    }
+                }
+                catch {
+                    instances = [];
+                }
+            }
+            instances = instances.filter(i => i.id !== id);
+            writeFileAtomic(this.registryPath, JSON.stringify(instances, null, 2), { mode: 0o644 });
+        });
+    }
+    startHeartbeat() {
+        this.heartbeatInterval = setInterval(() => {
+            if (this.currentInstance) {
+                this.currentInstance.lastHeartbeat = Date.now();
+                this.saveInstance(this.currentInstance);
+            }
+        }, 30000);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+}
+export function deriveSpaceBrowserAgentId(clientId, workingDirectory) {
+    const canonical = `${clientId}\u0000${resolve(workingDirectory)}`;
+    const digest = createHash('sha256').update(canonical).digest('hex');
+    return `space-${digest.slice(0, 32)}`;
+}
+export function buildRespawnEnv(source, workingDirectory, isWin = process.platform === 'win32') {
+    const env = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (value === undefined)
+            continue;
+        if (/^npm_/i.test(key))
+            continue;
+        if (/^PORT$/i.test(key))
+            continue;
+        if (key === 'MINIONRY_ALLOW_DUPLICATE')
+            continue;
+        if (key === 'MINIONRY_SUPERSEDES_PID')
+            continue;
+        env[key] = value;
+    }
+    collapsePath(env, isWin);
+    env.MINIONRY_WORKING_DIR = workingDirectory;
+    return env;
+}
+function collapsePath(env, isWin) {
+    if (!isWin) {
+        if (env.PATH)
+            env.PATH = dedupePathValue(env.PATH, false);
+        return;
+    }
+    const keys = Object.keys(env).filter((k) => /^path$/i.test(k));
+    if (keys.length === 0)
+        return;
+    const segments = [];
+    for (const k of keys) {
+        const value = env[k];
+        if (value)
+            segments.push(value);
+        delete env[k];
+    }
+    env.Path = dedupePathValue(segments.join(delimiter), true);
+}
+function dedupePathValue(raw, caseInsensitive) {
+    const seen = new Set();
+    const out = [];
+    for (const seg of raw.split(delimiter)) {
+        if (!seg)
+            continue;
+        const norm = caseInsensitive ? seg.toLowerCase() : seg;
+        if (seen.has(norm))
+            continue;
+        seen.add(norm);
+        out.push(seg);
+    }
+    return out.join(delimiter);
+}
+const updateLockDir = () => machineLockPath('update');
+const UPDATE_LOCK_STALE_MS = 10 * 60 * 1000;
+export function clearStaleUpdateLock(now = Date.now()) {
+    try {
+        const lockDir = updateLockDir();
+        if (!existsSync(lockDir))
+            return;
+        if (now - statSync(lockDir).mtimeMs < UPDATE_LOCK_STALE_MS)
+            return;
+        rmSync(lockDir, { recursive: true, force: true });
+    }
+    catch {
+    }
+}
+export function buildRespawnPlan(clientRoot, { update, isWin = process.platform === 'win32', lockDir = updateLockDir(), execPath = process.execPath, stableDir = homedir(), }) {
+    const npmCmd = isWin ? 'npm.cmd' : 'npm';
+    const relaunch = `${npmCmd} run --silent start`;
+    if (!update) {
+        return { command: npmCmd, args: ['run', '--silent', 'start'], cwd: clientRoot };
+    }
+    const quote = (s) => (isWin ? `"${s}"` : `'${s}'`);
+    const minionUpdate = `${quote(execPath)} ${quote(join(clientRoot, 'bin', 'minion.js'))} update`;
+    if (isWin) {
+        const chain = `md "${lockDir}" 2>nul && (set MINIONRY_SKIP_UPDATE_CHECK=1& ${minionUpdate} & rd /s /q "${lockDir}") ` +
+            `|| (for /l %i in (1,1,60) do @(if not exist "${lockDir}" goto :go) & timeout /t 5 /nobreak >nul) ` +
+            `& :go & cd /d "${clientRoot}" && ${relaunch}`;
+        return { command: 'cmd.exe', args: ['/c', chain], cwd: stableDir };
+    }
+    const chain = `if mkdir '${lockDir}' 2>/dev/null; then MINIONRY_SKIP_UPDATE_CHECK=1 ${minionUpdate}; rmdir '${lockDir}' 2>/dev/null; ` +
+        `else n=0; while [ -d '${lockDir}' ] && [ $n -lt 120 ]; do sleep 5; n=$((n+1)); done; fi; ` +
+        `cd '${clientRoot}' && ${relaunch}`;
+    return { command: 'sh', args: ['-c', chain], cwd: stableDir };
+}
+export function respawnInstance(workingDirectory, options = {}) {
+    const logDir = machinePath('logs');
+    if (!existsSync(logDir))
+        mkdirSync(logDir, { recursive: true });
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const logFd = openSync(join(logDir, `minionry-restart-${stamp}.log`), 'a');
+    const clientRoot = MINIONRY_ROOT;
+    const update = options.update === true;
+    if (update)
+        clearStaleUpdateLock();
+    const plan = buildRespawnPlan(clientRoot, { update });
+    const env = buildRespawnEnv(process.env, workingDirectory);
+    env.MINIONRY_SUPERSEDES_PID = String(process.pid);
+    const child = spawn(plan.command, plan.args, {
+        cwd: plan.cwd,
+        stdio: ['ignore', logFd, logFd],
+        env,
+        detached: true,
+        ...(process.platform === 'win32'
+            ? {
+                windowsHide: true,
+                windowsVerbatimArguments: plan.command === 'cmd.exe',
+            }
+            : {}),
+    });
+    child.on('error', (err) => {
+        console.error('[respawnInstance] Failed to relaunch minion server:', err);
+    });
+    child.unref();
+    closeSync(logFd);
+}