@turns/dev 0.0.1

package/dist/file-browsing.js

@@ -0,0 +1,241 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { workingDirectoryIsAllowed } from "./directory-policy.js";
+import { uploadFileBytes, uploadFileStream } from "./path-resolution.js";
+/**
+ * Answering "what is in that directory?" from the machine that knows.
+ *
+ * A reader's browser cannot reach this machine, and this machine will not open
+ * a port to let it try. So a browse is served the way an embedded image already
+ * is: the daemon reads the path, puts what it found in the account's own
+ * prefix, and the server hands the reader a signed URL for that object. Regular
+ * files stream from disk to that object; nothing stays open once the one browse
+ * upload finishes.
+ *
+ * A directory has no bytes, so what is uploaded for one is a listing of it,
+ * stored at `_index.json` beneath the directory. Every path is canonicalised
+ * before the allowlist is consulted, so a symlink pointing out of an allowed
+ * tree is not a way to read the rest of the disk.
+ */
+/** Kept in step with `MAX_DIRECTORY_ENTRIES` in the Worker's shared listing. */
+export const MAX_DIRECTORY_ENTRIES = 2_000;
+/** Kept in step with `DIRECTORY_INDEX_NAME` in the Worker's shared listing. */
+export const DIRECTORY_INDEX_NAME = '_index.json';
+/** One MB below the Worker request-body ceiling, matching the R2 endpoint. */
+export const MAX_BROWSE_FILE_BYTES = 199 * 1024 * 1024;
+/** The derived label used in reader-facing errors. */
+export const BROWSE_FILE_LIMIT_LABEL = `${Math.round(MAX_BROWSE_FILE_BYTES / (1024 * 1024))} MB`;
+/** Extensions a reader can be shown as text, whatever produced them. */
+const TEXT_EXTENSIONS = new Set([
+    '.bash',
+    '.c',
+    '.cc',
+    '.cfg',
+    '.conf',
+    '.cpp',
+    '.cs',
+    '.css',
+    '.csv',
+    '.diff',
+    '.env',
+    '.go',
+    '.gradle',
+    '.h',
+    '.hpp',
+    '.htm',
+    '.html',
+    '.ini',
+    '.java',
+    '.jsonl',
+    '.jsx',
+    '.kt',
+    '.less',
+    '.lock',
+    '.log',
+    '.lua',
+    '.m',
+    '.md',
+    '.mjs',
+    '.cjs',
+    '.mts',
+    '.patch',
+    '.php',
+    '.pl',
+    '.properties',
+    '.py',
+    '.r',
+    '.rb',
+    '.rs',
+    '.scss',
+    '.sh',
+    '.sql',
+    '.swift',
+    '.tf',
+    '.toml',
+    '.ts',
+    '.tsx',
+    '.txt',
+    '.vue',
+    '.xml',
+    '.yaml',
+    '.yml',
+    '.zsh',
+]);
+/** Extensions carrying their own type, where guessing text would be wrong. */
+const BINARY_CONTENT_TYPES = new Map([
+    ['.apng', 'image/apng'],
+    ['.avif', 'image/avif'],
+    ['.bmp', 'image/bmp'],
+    ['.gif', 'image/gif'],
+    ['.gz', 'application/gzip'],
+    ['.heic', 'image/heic'],
+    ['.ico', 'image/x-icon'],
+    ['.jpeg', 'image/jpeg'],
+    ['.jpg', 'image/jpeg'],
+    ['.mp3', 'audio/mpeg'],
+    ['.mp4', 'video/mp4'],
+    ['.pdf', 'application/pdf'],
+    ['.png', 'image/png'],
+    ['.svg', 'image/svg+xml'],
+    ['.wasm', 'application/wasm'],
+    ['.webm', 'video/webm'],
+    ['.webp', 'image/webp'],
+    ['.zip', 'application/zip'],
+]);
+/**
+ * How one browsed file should be served back.
+ *
+ * A name with no extension at all — `README`, `Makefile`, `Dockerfile` — is
+ * nearly always text, and is the one guess worth making. Everything unrecognised
+ * is served as bytes: the Worker sends it with `nosniff` under a sandboxing
+ * policy, so an unhelpful type is only ever unhelpful.
+ */
+export function browseContentType(file) {
+    const extension = path.extname(file).toLowerCase();
+    const known = BINARY_CONTENT_TYPES.get(extension);
+    if (known)
+        return known;
+    if (extension === '.json')
+        return 'application/json';
+    if (!extension || TEXT_EXTENSIONS.has(extension))
+        return 'text/plain; charset=utf-8';
+    return 'application/octet-stream';
+}
+function isoTime(value) {
+    return Number.isFinite(value) ? new Date(value).toISOString() : '';
+}
+/**
+ * The path a browse settled on, with what the filesystem says it is.
+ *
+ * A relative path or a bare `~` is the reader's shorthand for somewhere inside
+ * the session's own tree, and is expanded here rather than being refused: the
+ * browser navigates by clicking, and the paths it clicks come from listings
+ * this machine wrote. Canonicalisation happens before the allowlist test, and
+ * the allowlist is the daemon's, not the session's.
+ */
+export function resolveBrowsePath(requested, { workingDirectory = '', allowedDirectories = [] } = {}) {
+    const raw = String(requested || '').trim();
+    const home = os.homedir();
+    const expanded = raw === '~' || raw.startsWith('~/') ? path.join(home, raw.slice(1)) : raw;
+    const base = workingDirectory || home;
+    const absolute = !expanded ? base : path.isAbsolute(expanded) ? expanded : path.resolve(base, expanded);
+    let canonical;
+    let stat;
+    try {
+        canonical = fs.realpathSync(absolute);
+        stat = fs.statSync(canonical);
+    }
+    catch {
+        throw new Error(`No such file or directory: ${absolute}`);
+    }
+    if (!stat.isFile() && !stat.isDirectory())
+        throw new Error(`Not a readable file or directory: ${canonical}`);
+    // The same allowlist the daemon runs harnesses under, asked about the
+    // directory a browse would show: an allowed root is browsable, and a file is
+    // reachable exactly when the directory holding it is.
+    if (!workingDirectoryIsAllowed(stat.isDirectory() ? canonical : path.dirname(canonical), allowedDirectories)) {
+        throw new Error(`Path is outside the daemon allowlist: ${canonical}`);
+    }
+    return { path: canonical, stat };
+}
+/**
+ * One directory as this machine sees it now.
+ *
+ * Each name is stat'ed through its symlink so a listing says what clicking it
+ * would open, and keeps the fact that it is a link. A name the machine cannot
+ * stat — a dangling link, a directory it may not enter — is still listed, with
+ * nothing claimed about it: leaving it out would misdescribe the directory.
+ */
+export function readDirectory(directory) {
+    const names = fs.readdirSync(directory, { withFileTypes: true });
+    const entries = names.slice(0, MAX_DIRECTORY_ENTRIES).map((name) => {
+        const symlink = name.isSymbolicLink();
+        let stat = null;
+        try {
+            stat = fs.statSync(path.join(directory, name.name));
+        }
+        catch { }
+        const kind = stat ? (stat.isDirectory() ? 'directory' : stat.isFile() ? 'file' : 'other') : 'other';
+        return {
+            name: name.name,
+            kind,
+            ...(stat?.isFile() ? { size: stat.size } : {}),
+            ...(stat ? { modifiedAt: isoTime(stat.mtimeMs) } : {}),
+            ...(symlink ? { symlink: true } : {}),
+        };
+    });
+    // No timestamp: the object's own upload time says when this was read, and a
+    // clock inside the body would make every read produce different bytes.
+    return { path: directory, entries, truncated: names.length > MAX_DIRECTORY_ENTRIES };
+}
+/** Where one directory's listing is stored, as a path in the machine's space. */
+export function directoryIndexPath(directory) {
+    return `${String(directory || '').replace(/\/+$/u, '')}/${DIRECTORY_INDEX_NAME}`;
+}
+/**
+ * Store one path for a reader, and say what was stored.
+ *
+ * An empty file is a legitimate thing to open and has no bytes to upload, so it
+ * is reported rather than sent — the reader is told the file is empty instead of
+ * being handed a URL for an object that was never written. A file past the
+ * upload ceiling is refused here, where the size is known, rather than by the
+ * Worker after the bytes have crossed the network.
+ */
+export async function browseMachinePath({ requested, machine, baseUrl, options, workingDirectory = '', fetchImpl = fetch, }) {
+    const resolved = resolveBrowsePath(requested, {
+        workingDirectory,
+        allowedDirectories: options.allowedDirectories || [],
+    });
+    if (resolved.stat.isDirectory()) {
+        const body = new TextEncoder().encode(JSON.stringify(readDirectory(resolved.path)));
+        if (body.byteLength > MAX_BROWSE_FILE_BYTES)
+            throw new Error(`Directory listing is too large: ${resolved.path}`);
+        await uploadFileBytes({
+            baseUrl,
+            options,
+            machine,
+            absolutePath: directoryIndexPath(resolved.path),
+            contentType: 'application/json',
+            body,
+            fetchImpl,
+        });
+        return { path: resolved.path, kind: 'directory', bytes: body.byteLength, contentType: 'application/json' };
+    }
+    const contentType = browseContentType(resolved.path);
+    if (resolved.stat.size > MAX_BROWSE_FILE_BYTES) {
+        throw new Error(`File is larger than the ${BROWSE_FILE_LIMIT_LABEL} browse limit.`);
+    }
+    if (resolved.stat.size === 0)
+        return { path: resolved.path, kind: 'file', bytes: 0, contentType };
+    await uploadFileStream({
+        baseUrl,
+        options,
+        machine,
+        absolutePath: resolved.path,
+        contentType,
+        bytes: resolved.stat.size,
+        fetchImpl,
+    });
+    return { path: resolved.path, kind: 'file', bytes: resolved.stat.size, contentType };
+}

package/dist/git-association.js

@@ -0,0 +1,136 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const MAX_WALK = 64;
+const MAX_REMOTE_NAME = 80;
+const MAX_REMOTE_URL = 2_000;
+const MAX_REMOTES = 20;
+const MAX_ROOT = 2_000;
+function existingDirectory(start) {
+    let dir = path.resolve(String(start || ''));
+    if (!dir)
+        return '';
+    for (let index = 0; index < MAX_WALK; index += 1) {
+        try {
+            const stat = fs.statSync(dir);
+            if (stat.isDirectory())
+                return dir;
+            if (stat.isFile())
+                dir = path.dirname(dir);
+            else
+                break;
+        }
+        catch {
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    return '';
+}
+function commonGitDir(gitDir) {
+    try {
+        const raw = fs.readFileSync(path.join(gitDir, 'commondir'), 'utf8').trim();
+        if (raw) {
+            const resolved = path.isAbsolute(raw) ? raw : path.resolve(gitDir, raw);
+            if (fs.statSync(resolved).isDirectory())
+                return resolved;
+        }
+    }
+    catch { }
+    try {
+        return fs.statSync(gitDir).isDirectory() ? gitDir : '';
+    }
+    catch {
+        return '';
+    }
+}
+function resolveGitDir(gitPath) {
+    let stat;
+    try {
+        stat = fs.statSync(gitPath);
+    }
+    catch {
+        return '';
+    }
+    if (stat.isDirectory())
+        return commonGitDir(gitPath);
+    if (!stat.isFile())
+        return '';
+    let text = '';
+    try {
+        text = fs.readFileSync(gitPath, 'utf8');
+    }
+    catch {
+        return '';
+    }
+    const match = /^\s*gitdir:\s*(.+?)\s*$/mu.exec(text);
+    if (!match)
+        return '';
+    const pointed = path.isAbsolute(match[1]) ? match[1] : path.resolve(path.dirname(gitPath), match[1]);
+    return commonGitDir(pointed);
+}
+export function readGitRemotes(gitDir) {
+    let config = '';
+    try {
+        config = fs.readFileSync(path.join(gitDir, 'config'), 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const remotes = [];
+    const seen = new Set();
+    let current = '';
+    for (const line of config.split(/\r?\n/u)) {
+        const section = /^\s*\[remote\s+"([^"]+)"\]\s*$/iu.exec(line) || /^\s*\[remote\s+([^\s\]]+)\]\s*$/iu.exec(line);
+        if (section) {
+            current = section[1];
+            continue;
+        }
+        if (/^\s*\[/u.test(line)) {
+            current = '';
+            continue;
+        }
+        if (!current)
+            continue;
+        const url = /^\s*url\s*=\s*(.+?)\s*$/iu.exec(line);
+        if (!url)
+            continue;
+        const name = String(current).trim().slice(0, MAX_REMOTE_NAME);
+        const value = String(url[1]).trim().slice(0, MAX_REMOTE_URL);
+        const key = `${name}\0${value}`;
+        if (!name || !value || seen.has(key))
+            continue;
+        seen.add(key);
+        remotes.push({ name, url: value });
+        if (remotes.length >= MAX_REMOTES)
+            break;
+    }
+    return remotes;
+}
+/** Nearest ancestor git work tree, including gitfile / worktree layouts. */
+export function findGitWorkTree(cwd) {
+    let dir = existingDirectory(cwd);
+    if (!dir)
+        return null;
+    for (let index = 0; index < MAX_WALK; index += 1) {
+        const gitDir = resolveGitDir(path.join(dir, '.git'));
+        if (gitDir)
+            return { root: dir.slice(0, MAX_ROOT), gitDir };
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/** Associate a session cwd with its enclosing git remotes, if any. */
+export function discoverGitAssociation(cwd) {
+    const found = findGitWorkTree(cwd);
+    if (!found)
+        return null;
+    const remotes = readGitRemotes(found.gitDir);
+    if (!found.root && !remotes.length)
+        return null;
+    return { root: found.root, remotes };
+}

package/dist/harness-registry.js

@@ -0,0 +1,323 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const HOME = os.homedir();
+// Turns owns this catalog.  It mirrors the transports verified by
+// turns/scaffolding; queue execution must never depend on another product's
+// discovery or process-launch implementation.
+export const ACP_PROFILES = {
+    grok: {
+        command: 'grok',
+        args: (permissionMode) => [
+            'agent',
+            // A shared leader retains its current always-approve state across ACP
+            // clients. Turns needs each anchor's requested permission mode to be
+            // authoritative, especially after a cold restart.
+            '--no-leader',
+            ...(permissionMode === 'bypassPermissions' ? ['--always-approve'] : []),
+            'stdio',
+        ],
+        mcp: true,
+    },
+    kimi: {
+        command: 'kimi',
+        args: ['acp'],
+        homePaths: [['.kimi-code', 'bin', 'kimi']],
+        options: (permissionMode) => [
+            {
+                id: 'mode',
+                value: permissionMode === 'bypassPermissions'
+                    ? 'yolo'
+                    : permissionMode === 'plan'
+                        ? 'plan'
+                        : permissionMode === 'default'
+                            ? 'default'
+                            : 'auto',
+            },
+        ],
+        mcp: true,
+    },
+    opencode: {
+        command: 'opencode',
+        args: ['acp'],
+        homePaths: [['.opencode', 'bin', 'opencode']],
+        options: [{ id: 'mode', value: 'build' }],
+        mcp: true,
+    },
+    devin: {
+        command: 'devin',
+        args: ['acp'],
+        mode: (permissionMode) => ({
+            auto: 'accept-edits',
+            default: 'accept-edits',
+            acceptEdits: 'accept-edits',
+            plan: 'plan',
+            bypassPermissions: 'bypass',
+        })[permissionMode] || 'accept-edits',
+    },
+    hermes: {
+        command: 'hermes',
+        args: ['acp'],
+        env: (_permissionMode, cwd) => ({
+            HERMES_HOME: path.join(HOME, '.hermes'),
+            HERMES_MANAGED_DIR: path.join(cwd, '.turns-hermes-managed'),
+        }),
+        mcp: true,
+    },
+    copilot: {
+        command: 'copilot',
+        args: (permissionMode) => ['--acp', ...(permissionMode === 'bypassPermissions' ? ['--allow-all-tools'] : [])],
+    },
+    openclaw: { command: 'openclaw', args: ['acp'] },
+    cline: {
+        command: 'cline',
+        args: (permissionMode) => ['--acp', '--auto-approve', permissionMode === 'bypassPermissions' ? 'true' : 'false'],
+        mode: 'act',
+        // Pin an authenticated, tool-capable provider/model so daemon-driven
+        // captures do not inherit a concurrently changing interactive selection.
+        options: [{ id: 'provider', value: 'openai-codex' }],
+        model: 'gpt-5.6-luna',
+    },
+    qwen: {
+        command: 'qwen',
+        args: ['--acp'],
+        // Qwen persists tools.approvalMode globally. Make the anchor's requested
+        // mode authoritative for every ACP session so a prior interactive YOLO
+        // selection cannot silently bypass daemon-driven permission requests.
+        mode: (permissionMode) => ({ acceptEdits: 'auto-edit', bypassPermissions: 'yolo' })[permissionMode] || permissionMode,
+        mcp: true,
+    },
+    kilo: {
+        command: 'kilo',
+        args: ['acp'],
+        homePaths: [['.kilo', 'bin', 'kilo']],
+        // Kilo's ACP model selector uses provider-qualified config values. The
+        // free auto route is available without a Kilo account and remains capable
+        // of exercising the local tools used by the driver.
+        model: 'kilo/kilo-auto/free',
+        mcp: true,
+    },
+    poolside: {
+        command: 'pool',
+        args: ['acp'],
+        resumeMethods: ['session/load'],
+        // Poolside exposes permission policy as an ACP config option rather than
+        // a session mode. Apply it per anchor so bypass runs cannot inherit its
+        // interactive `default` (always ask) selection.
+        options: (permissionMode) => [
+            {
+                id: 'mode',
+                value: permissionMode === 'bypassPermissions'
+                    ? 'always-allow'
+                    : permissionMode === 'acceptEdits'
+                        ? 'accept-edits'
+                        : 'default',
+            },
+        ],
+        mcp: true,
+    },
+    goose: {
+        command: 'goose',
+        args: ['acp', '--with-builtin', 'developer,summon'],
+        // Goose defaults resumed sessions to `auto`. Set the advertised ACP mode
+        // from the daemon request so permission companions actually ask.
+        mode: (permissionMode) => ({ default: 'approve', acceptEdits: 'smart_approve', bypassPermissions: 'auto' })[permissionMode] || 'auto',
+        mcp: true,
+    },
+    codebuddy: {
+        command: 'codebuddy',
+        args: (permissionMode) => ['--acp', '--permission-mode', permissionMode],
+        mcp: true,
+    },
+    gemini: {
+        command: 'gemini',
+        args: (permissionMode) => [
+            '--acp',
+            '--approval-mode',
+            { acceptEdits: 'auto_edit', bypassPermissions: 'yolo' }[permissionMode] || permissionMode,
+        ],
+        // Gemini can persist very short sessions without making them discoverable
+        // to session/load. Starting a replacement session is safe for callers that
+        // do not require prior context; context-sensitive restart tests still
+        // detect an unexpected fallback through their semantic assertions.
+        resumeFallbackToNew: true,
+        mcp: true,
+    },
+    vibe: { command: 'vibe-acp', args: [], mcp: true },
+};
+// These harnesses keep one bidirectional process attached to the anchor. They
+// are listed separately from process harnesses so queued turns cannot
+// accidentally fall back to one-shot CLI invocations.
+export const RESIDENT_HARNESSES = new Set(['claude', 'codex']);
+export const RPC_PROFILES = {
+    // Prime selects an existing session only at process launch. The transcript
+    // path is authoritative (its header id can differ from its filename id), so
+    // resume the exact file; omit --resume only for an explicit new-chat launch.
+    prime: {
+        command: 'prime-agent',
+        args: (anchor, createSession = false) => [
+            '--mode',
+            'rpc',
+            '--cwd',
+            anchor.cwd,
+            ...(createSession ? [] : ['--resume', anchor.transcriptPath]),
+        ],
+    },
+    omp: {
+        command: 'omp',
+        args: (anchor, createSession = false) => [
+            '--mode',
+            'rpc',
+            '--cwd',
+            anchor.cwd,
+            '--approval-mode',
+            anchor.permissionMode === 'default' ? 'always-ask' : 'yolo',
+            ...(createSession ? [] : ['--resume', anchor.transcriptPath]),
+        ],
+    },
+};
+export const PROCESS_HARNESSES = new Set(['cursor', 'pi', 'muse', 'antigravity']);
+export function processEventSessionId(harness, event) {
+    if (!PROCESS_HARNESSES.has(harness) || !event || typeof event !== 'object' || Array.isArray(event))
+        return '';
+    for (const key of ['session_id', 'sessionId', 'run_id', 'runId', 'conversation_id', 'conversationId']) {
+        const value = String(event[key] || '').trim();
+        if (value)
+            return value;
+    }
+    return '';
+}
+export function rpcFrameSessionIdentity(frame) {
+    if (!frame || typeof frame !== 'object' || Array.isArray(frame))
+        return { sessionId: '', transcriptPath: '' };
+    const state = frame.data || frame.state;
+    if (!state || typeof state !== 'object' || Array.isArray(state))
+        return { sessionId: '', transcriptPath: '' };
+    return {
+        sessionId: String(state.sessionId || state.id || '').trim(),
+        transcriptPath: String(state.sessionFile || '').trim(),
+    };
+}
+export function rpcUiRequestIsInformational(frame) {
+    if (frame?.type !== 'extension_ui_request')
+        return false;
+    const method = String(frame.method || '');
+    return (!['confirm', 'select', 'input', 'editor'].includes(method) &&
+        !/permission|approval/iu.test(`${method} ${frame.title || ''}`));
+}
+export const HARNESS_IDS = [
+    ...RESIDENT_HARNESSES,
+    ...PROCESS_HARNESSES,
+    ...Object.keys(RPC_PROFILES),
+    'deepseek',
+    ...Object.keys(ACP_PROFILES),
+];
+function executable(candidate) {
+    try {
+        fs.accessSync(candidate, fs.constants.X_OK);
+        return candidate;
+    }
+    catch {
+        return '';
+    }
+}
+export function resolveHarnessCommand(harness, profile = {}) {
+    const envName = `TURNS_${String(harness).toUpperCase().replaceAll('-', '_')}_BIN`;
+    const configured = String(process.env[envName] || '').trim();
+    if (configured) {
+        const found = executable(path.resolve(configured));
+        if (found)
+            return found;
+        throw new Error(`${envName} is not executable: ${configured}`);
+    }
+    const command = profile.command || ({ cursor: 'cursor-agent', antigravity: 'agy' }[harness] ?? harness);
+    for (const directory of String(process.env.PATH || '').split(path.delimiter)) {
+        const found = executable(path.join(directory, command));
+        if (found)
+            return found;
+    }
+    for (const segments of profile.homePaths || []) {
+        const found = executable(path.join(HOME, ...segments));
+        if (found)
+            return found;
+    }
+    if (harness === 'cursor') {
+        for (const candidate of [
+            path.join(HOME, '.local', 'bin', 'cursor-agent'),
+            path.join(HOME, '.local', 'bin', 'agent'),
+        ]) {
+            const found = executable(candidate);
+            if (found)
+                return found;
+        }
+    }
+    throw new Error(`Agent executable not found for harness "${harness}" (${command}).`);
+}
+export function processInvocation({ harness, sessionId, transcriptPath, cwd, prompt, createSession, model, thinkingLevel, timeoutMs, }) {
+    const command = resolveHarnessCommand(harness);
+    if (harness === 'cursor')
+        return {
+            command,
+            args: [
+                '--print',
+                '--output-format',
+                'stream-json',
+                '--stream-partial-output',
+                '--force',
+                '--trust',
+                '--workspace',
+                cwd,
+                ...(model && model !== 'auto' ? ['--model', model] : []),
+                ...(createSession ? [] : ['--resume', sessionId]),
+                prompt,
+            ],
+        };
+    if (harness === 'pi')
+        return {
+            command,
+            args: [
+                '--mode',
+                'json',
+                '--approve',
+                ...(model && model !== 'auto' ? ['--model', model] : []),
+                ...(thinkingLevel ? ['--thinking', thinkingLevel] : []),
+                ...(createSession ? ['--session-id', sessionId] : ['--session', transcriptPath || sessionId]),
+                prompt,
+            ],
+        };
+    if (harness === 'muse')
+        return {
+            command,
+            args: [
+                'exec',
+                '--json',
+                '--workspace',
+                cwd,
+                '--yolo',
+                '--session-id',
+                sessionId,
+                ...(!createSession ? ['--allow-workspace-switch'] : []),
+                ...(model && model !== 'auto' ? ['--model', model] : []),
+                ...(thinkingLevel ? ['--reasoning-effort', thinkingLevel === 'max' ? 'ultra' : thinkingLevel] : []),
+                prompt,
+            ],
+        };
+    if (harness === 'antigravity')
+        return {
+            command,
+            args: [
+                '--print',
+                prompt,
+                '--output-format',
+                'stream-json',
+                '--add-dir',
+                cwd,
+                ...(createSession ? [] : ['--conversation', sessionId]),
+                ...(model && model !== 'auto' ? ['--model', model] : []),
+                '--dangerously-skip-permissions',
+                '--print-timeout',
+                `${Math.max(1, Math.ceil(timeoutMs / 1000))}s`,
+            ],
+        };
+    throw new Error(`No Turns process profile exists for harness "${harness}".`);
+}