agentic-engineering-harness 0.6.13 → 0.6.14

package/dist/operations/controller.js

@@ -1,35 +1,66 @@
 import crypto from "node:crypto";
 import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
 import { runAudit } from "../audit/run.js";
 import { loadProjectConfig, loadTaskContract } from "../core/config.js";
 import { runTask } from "../core/run.js";
+import { deliveryWorkspaceId, deliveryWorkspacePath, materializeTaskContext } from "../delivery/handoff.js";
 import { listManagedPaseoAgents } from "../paseo/runtime.js";
 import { recordPaseoTrace } from "../paseo/trace.js";
 import { runProcess } from "../utils/process.js";
+import { runChangeOperation } from "./change.js";
 import { disableOperationCompletionTarget, notifyOperationCompletion, registerOperationCompletionTarget } from "./completion.js";
-import { loadOperation, patchOperation, saveOperation, transitionOperationToTerminal } from "./state.js";
+import { startOperationWatchdog } from "./liveness.js";
+import { assertOperationCapacity, syncOperationPortfolio } from "./portfolio.js";
+import { bindOperationLead, isTerminalOperation, loadOperation, patchOperation, saveOperation, transitionOperationToTerminal } from "./state.js";
 export async function startDetachedOperation(root, kind, payload, options) {
     const absoluteRoot = path.resolve(root);
+    const config = await loadProjectConfigIfPresent(absoluteRoot);
+    if (config)
+        await assertOperationCapacity(absoluteRoot, config, operationPriority(payload));
     const now = new Date().toISOString();
     const id = createOperationId(kind, JSON.stringify(payload));
-    const record = {
-        version: 1,
+    let record = {
+        version: 2,
         id,
         kind,
         status: "QUEUED",
         phase: "queued",
         root: absoluteRoot,
         payload,
+        revision: 1,
         createdAt: now,
-        updatedAt: now
+        updatedAt: now,
+        lastProgressAt: now,
+        intent: initialIntent(kind, payload),
+        supervision: {
+            required: kind === "audit" || kind === "change",
+            materialized: false,
+            generations: []
+        },
+        stages: {
+            queued: {
+                name: "queued",
+                status: "RUNNING",
+                revision: 1,
+                startedAt: now
+            }
+        },
+        participants: {},
+        progress: { expected: 0, registered: 0, running: 0, completed: 0, failed: 0, blocked: 0 },
+        notification: { lastLeadWakeRevision: 0, terminalDelivered: false, attempts: 0 }
     };
     await saveOperation(absoluteRoot, record);
     const completionAgentId = options.completionAgentId?.trim() || process.env.PASEO_AGENT_ID?.trim() || undefined;
     if (completionAgentId) {
-        await registerOperationCompletionTarget(absoluteRoot, id, completionAgentId, options.completionSource ?? (options.completionAgentId ? "explicit" : "environment"));
+        const source = options.completionSource ?? (options.completionAgentId ? "explicit" : "environment");
+        await registerOperationCompletionTarget(absoluteRoot, id, completionAgentId, source);
+        record = await bindOperationLead(absoluteRoot, id, completionAgentId, source);
     }
+    if (config)
+        await syncOperationPortfolio(absoluteRoot, config.project.name, record);
     const spawnProcess = options.spawnProcess ?? spawn;
     let child;
     try {
@@ -39,6 +70,7 @@ export async function startDetachedOperation(root, kind, payload, options) {
             stdio: "ignore",
             env: {
                 ...process.env,
+                AEH_CONTROL_ROOT: absoluteRoot,
                 AEH_OPERATION_ID: id,
                 AEH_OPERATION_KIND: kind
             }
@@ -48,21 +80,28 @@ export async function startDetachedOperation(root, kind, payload, options) {
         if (completionAgentId) {
             await disableOperationCompletionTarget(absoluteRoot, id, `Detached controller spawn failed before the initiating tool returned: ${String(error)}`).catch(() => undefined);
         }
-        return patchOperation(absoluteRoot, id, {
+        record = await patchOperation(absoluteRoot, id, {
             status: "FAILED",
             phase: "spawn-failed",
             error: String(error),
             finishedAt: new Date().toISOString()
         });
+        if (config)
+            await syncOperationPortfolio(absoluteRoot, config.project.name, record);
+        return record;
     }
     child.unref();
-    return patchOperation(absoluteRoot, id, {
+    record = await patchOperation(absoluteRoot, id, {
         pid: child.pid,
         phase: "dispatched"
     });
+    if (config)
+        await syncOperationPortfolio(absoluteRoot, config.project.name, record);
+    return record;
 }
 export async function executeOperation(root, operationId, deps = {}) {
     const absoluteRoot = path.resolve(root);
+    process.env.AEH_CONTROL_ROOT = absoluteRoot;
     const trace = deps.trace ?? recordPaseoTrace;
     let record = await loadOperation(absoluteRoot, operationId);
     if (record.status === "CANCELLED")
@@ -70,33 +109,30 @@ export async function executeOperation(root, operationId, deps = {}) {
     record = await patchOperation(absoluteRoot, operationId, {
         status: "RUNNING",
         phase: "preparing",
-        startedAt: new Date().toISOString(),
+        startedAt: record.startedAt ?? new Date().toISOString(),
         pid: process.pid,
         error: undefined
     });
     process.env.AEH_OPERATION_ID = record.id;
     process.env.AEH_OPERATION_KIND = record.kind;
-    const workspace = await ensureOperationWorkspace(absoluteRoot, record, deps.run ?? runProcess, trace);
-    if (workspace.workspaceId) {
-        process.env.AEH_OPERATION_WORKSPACE_ID = workspace.workspaceId;
+    const config = await loadProjectConfig(absoluteRoot);
+    await syncOperationPortfolio(absoluteRoot, config.project.name, record);
+    let stopWatchdog;
+    try {
+        const workspace = await ensureOperationWorkspace(absoluteRoot, record, config, deps.run ?? runProcess, trace);
+        if (workspace.workspaceId)
+            process.env.AEH_OPERATION_WORKSPACE_ID = workspace.workspaceId;
+        const executionRoot = path.resolve(workspace.workspaceRoot ?? absoluteRoot);
         record = await patchOperation(absoluteRoot, operationId, {
             workspaceId: workspace.workspaceId,
-            workspaceWarning: undefined
-        });
-    }
-    else if (workspace.warning) {
-        record = await patchOperation(absoluteRoot, operationId, {
+            workspaceRoot: executionRoot,
             workspaceWarning: workspace.warning
         });
-    }
-    try {
-        const config = await loadProjectConfig(absoluteRoot);
+        await syncOperationPortfolio(absoluteRoot, config.project.name, record);
+        stopWatchdog = (deps.startWatchdog ?? startOperationWatchdog)(absoluteRoot, config, operationId);
         if (record.kind === "audit") {
             const payload = record.payload;
-            const report = await runAudit(absoluteRoot, config, {
-                ...payload,
-                auditId: record.id
-            });
+            const report = await runAudit(executionRoot, config, { ...payload, auditId: record.id });
             const current = await loadOperation(absoluteRoot, operationId);
             if (current.status === "CANCELLED")
                 return current;
@@ -110,13 +146,33 @@ export async function executeOperation(root, operationId, deps = {}) {
                     productionSafe: report.productionSafe,
                     report: `.harness/audits/${report.auditId}.json`
                 }
-            }, deps);
+            }, deps, config);
+        }
+        if (record.kind === "change") {
+            const result = await runChangeOperation(executionRoot, absoluteRoot, config, await loadOperation(absoluteRoot, operationId), record.payload);
+            const current = await loadOperation(absoluteRoot, operationId);
+            if (current.status === "CANCELLED")
+                return current;
+            return terminalizeOperation(absoluteRoot, operationId, {
+                status: result.run.status === "PASS" ? "SUCCEEDED" : "FAILED",
+                phase: "finished",
+                finishedAt: new Date().toISOString(),
+                result: {
+                    taskId: result.taskId,
+                    mode: result.mode,
+                    status: result.run.status,
+                    attempts: result.run.attempts,
+                    specChange: result.specChange,
+                    triageReasons: result.triageReasons
+                }
+            }, deps, config);
         }
         const payload = record.payload;
         const contract = await loadTaskContract(absoluteRoot, payload.taskId, config);
-        const result = await runTask(absoluteRoot, config, contract, {
-            profile: payload.profile
-        });
+        if (executionRoot !== absoluteRoot) {
+            await materializeTaskContext(absoluteRoot, executionRoot, config, contract);
+        }
+        const result = await runTask(executionRoot, config, contract, { profile: payload.profile });
         const current = await loadOperation(absoluteRoot, operationId);
         if (current.status === "CANCELLED")
             return current;
@@ -129,7 +185,7 @@ export async function executeOperation(root, operationId, deps = {}) {
                 status: result.status,
                 attempts: result.attempts
             }
-        }, deps);
+        }, deps, config);
     }
     catch (error) {
         const current = await loadOperation(absoluteRoot, operationId).catch(() => record);
@@ -140,18 +196,20 @@ export async function executeOperation(root, operationId, deps = {}) {
             phase: "failed",
             error: error instanceof Error ? error.stack ?? error.message : String(error),
             finishedAt: new Date().toISOString()
-        }, deps);
+        }, deps, config);
+    }
+    finally {
+        stopWatchdog?.();
     }
 }
 export async function waitForOperation(root, operationId, timeoutMs = 1_800_000, pollMs = 500) {
     const deadline = Date.now() + timeoutMs;
     for (;;) {
         const record = await loadOperation(root, operationId);
-        if (isTerminal(record.status))
+        if (isTerminalOperation(record.status))
             return record;
-        if (Date.now() >= deadline) {
+        if (Date.now() >= deadline)
             throw new Error(`Timed out waiting for operation ${operationId} after ${timeoutMs}ms.`);
-        }
         await new Promise((resolve) => setTimeout(resolve, pollMs));
     }
 }
@@ -160,7 +218,7 @@ export async function cancelOperation(root, operationId, deps = {}) {
     const trace = deps.trace ?? recordPaseoTrace;
     const run = deps.run ?? runProcess;
     const record = await loadOperation(absoluteRoot, operationId);
-    if (isTerminal(record.status))
+    if (isTerminalOperation(record.status))
         return record;
     const cleanupWarnings = [];
     if (record.pid && record.pid !== process.pid) {
@@ -168,81 +226,53 @@ export async function cancelOperation(root, operationId, deps = {}) {
             process.kill(record.pid, "SIGTERM");
         }
         catch (error) {
-            if (!/ESRCH/.test(String(error))) {
+            if (!/ESRCH/.test(String(error)))
                 cleanupWarnings.push(`controller: ${String(error)}`);
-            }
         }
     }
     let agentIds = [...new Set((record.agents ?? []).map((agent) => agent.id).filter(Boolean))];
     if (agentIds.length > 0) {
-        await trace(absoluteRoot, "cleanup.discovery", {
-            operationId,
-            source: "operation-state",
-            agentCount: agentIds.length
-        });
+        await trace(absoluteRoot, "cleanup.discovery", { operationId, source: "operation-state", agentCount: agentIds.length });
     }
     else {
         try {
-            const discovered = await listManagedPaseoAgents(absoluteRoot, {
-                "aeh.operation": operationId
-            });
+            const discovered = await listManagedPaseoAgents(absoluteRoot, { "aeh.operation": operationId });
             agentIds = [...new Set(discovered.map((agent) => agent.id))];
-            await trace(absoluteRoot, "cleanup.discovery", {
-                operationId,
-                source: "paseo-list-compatibility",
-                agentCount: agentIds.length,
-                reason: "legacy operation record has no registered agent identities"
-            });
+            await trace(absoluteRoot, "cleanup.discovery", { operationId, source: "paseo-list-compatibility", agentCount: agentIds.length, reason: "legacy operation record has no registered agent identities" });
         }
         catch (error) {
             cleanupWarnings.push(`agent discovery: ${String(error)}`);
-            await trace(absoluteRoot, "cleanup.cli.error", {
-                operationId,
-                error: String(error)
-            });
+            await trace(absoluteRoot, "cleanup.cli.error", { operationId, error: String(error) });
         }
     }
     await trace(absoluteRoot, "cleanup.cli.required", {
         operationId,
-        reason: "Paseo public SDK 0.3.1 lacks cancel/kill parity for external controller cleanup",
+        reason: "Paseo public SDK lacks cancel/kill parity for external controller cleanup",
         agentCount: agentIds.length
     });
     for (const agentId of agentIds) {
-        const stopped = await run(`paseo stop ${quote(agentId)}`, {
-            cwd: absoluteRoot,
-            timeoutMs: 30_000
-        }).catch((error) => ({
-            exitCode: 1,
-            stdout: "",
-            stderr: String(error),
-            durationMs: 0
-        }));
-        await trace(absoluteRoot, "cleanup.cli.stop", {
-            operationId,
-            agentId,
-            exitCode: stopped.exitCode
-        });
-        if (stopped.exitCode !== 0) {
+        const stopped = await run(`paseo stop ${quote(agentId)}`, { cwd: absoluteRoot, timeoutMs: 30_000 }).catch((error) => ({ exitCode: 1, stdout: "", stderr: String(error), durationMs: 0 }));
+        await trace(absoluteRoot, "cleanup.cli.stop", { operationId, agentId, exitCode: stopped.exitCode });
+        if (stopped.exitCode !== 0)
             cleanupWarnings.push(`agent ${agentId}: ${stopped.stderr || stopped.stdout || `exit ${stopped.exitCode}`}`);
-        }
     }
+    const config = await loadProjectConfigIfPresent(absoluteRoot);
     return terminalizeOperation(absoluteRoot, operationId, {
         status: "CANCELLED",
         phase: "cancelled",
         finishedAt: new Date().toISOString(),
         cleanupWarnings: cleanupWarnings.length ? cleanupWarnings : undefined
-    }, deps);
+    }, deps, config);
 }
 export function createOperationId(kind, seed) {
-    const stamp = new Date()
-        .toISOString()
-        .replace(/[-:]/g, "")
-        .replace(/\.\d{3}Z$/, "Z");
+    const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
     const hash = crypto.createHash("sha256").update(seed).digest("hex").slice(0, 8);
     return `${kind.toUpperCase()}-${stamp}-${hash}`;
 }
-async function terminalizeOperation(root, operationId, patch, deps) {
+async function terminalizeOperation(root, operationId, patch, deps, config) {
     const { record: terminal, transitioned } = await transitionOperationToTerminal(root, operationId, patch);
+    if (config)
+        await syncOperationPortfolio(root, config.project.name, terminal).catch(() => undefined);
     if (!transitioned)
         return terminal;
     const trace = deps.trace ?? recordPaseoTrace;
@@ -260,56 +290,71 @@ async function terminalizeOperation(root, operationId, patch, deps) {
             boundary: "controller"
         }).catch(() => undefined);
     }
-    return terminal;
+    return loadOperation(root, operationId).catch(() => terminal);
 }
-async function ensureOperationWorkspace(root, record, run, trace) {
-    const title = `AEH ${record.kind.toUpperCase()} · ${record.id}`;
-    const command = `paseo workspace create --isolation local --path ${quote(root)} --title ${quote(title)} --json`;
-    await trace(root, "workspace.cli.required", {
-        operationId: record.id,
-        kind: record.kind,
-        reason: "Paseo SDK 0.3.1 workspace create lacks isolation/title parity",
-        isolation: "local"
-    });
-    let result;
-    try {
-        result = await run(command, { cwd: root, timeoutMs: 60_000 });
+async function ensureOperationWorkspace(root, record, config, run, trace) {
+    if (record.kind === "run") {
+        const payload = record.payload;
+        const [existingRoot, existingId] = await Promise.all([
+            deliveryWorkspacePath(root, config, payload.taskId),
+            deliveryWorkspaceId(root, config, payload.taskId)
+        ]);
+        if (existingRoot) {
+            await trace(root, "workspace.delivery.reused", {
+                operationId: record.id,
+                workspaceId: existingId ?? "",
+                workspaceRoot: existingRoot
+            });
+            return { workspaceId: existingId, workspaceRoot: existingRoot, reusedDelivery: true };
+        }
     }
-    catch (error) {
-        await trace(root, "workspace.cli.error", {
-            operationId: record.id,
-            error: String(error)
-        });
-        return {
-            warning: `Paseo operation workspace could not be created: ${String(error)}`
-        };
+    const title = `AEH ${record.kind.toUpperCase()} · ${record.id}`;
+    if (record.kind === "audit") {
+        const command = `paseo workspace create --isolation local --path ${quote(root)} --title ${quote(title)} --json`;
+        await trace(root, "workspace.cli.required", { operationId: record.id, kind: record.kind, reason: "Paseo public SDK workspace create lacks isolation/title parity", isolation: "local" });
+        const result = await safeRun(run, command, root, 60_000);
+        if (result.exitCode !== 0) {
+            const warning = `Paseo audit workspace could not be created: ${result.stderr || result.stdout || `exit ${result.exitCode}`}`;
+            await trace(root, "workspace.cli.error", { operationId: record.id, error: warning });
+            // AUDIT is read-only, so a local workspace failure does not create a
+            // write race; execution may continue at the repository root.
+            return { workspaceRoot: root, warning };
+        }
+        return { workspaceId: extractWorkspaceId(result.stdout), workspaceRoot: root };
     }
+    const slug = `aeh-${record.id.toLowerCase().replace(/[^a-z0-9-]+/g, "-").slice(0, 80)}`;
+    const branch = `aeh/op-${record.id.toLowerCase().replace(/[^a-z0-9-]+/g, "-").slice(0, 96)}`;
+    const base = config.validation?.baseRef ?? "HEAD";
+    const command = [
+        "paseo workspace create",
+        "--isolation worktree",
+        `--path ${quote(root)}`,
+        "--mode branch-off",
+        `--new-branch ${quote(branch)}`,
+        `--base ${quote(base)}`,
+        `--worktree-slug ${quote(slug)}`,
+        `--title ${quote(title)}`,
+        "--json"
+    ].join(" ");
+    await trace(root, "workspace.cli.required", { operationId: record.id, kind: record.kind, reason: "mutating operations require isolated worktree execution", isolation: "worktree", branch, base });
+    const result = await safeRun(run, command, root, 180_000);
     if (result.exitCode !== 0) {
-        await trace(root, "workspace.cli.error", {
-            operationId: record.id,
-            exitCode: result.exitCode,
-            error: result.stderr || result.stdout
-        });
-        return {
-            warning: `Paseo operation workspace could not be created: ${result.stderr || result.stdout || `exit ${result.exitCode}`}`
-        };
-    }
-    const workspaceId = extractWorkspaceId(result.stdout);
-    if (workspaceId) {
-        await trace(root, "workspace.cli.created", {
-            operationId: record.id,
-            workspaceId,
-            isolation: "local"
-        });
-        return { workspaceId };
+        throw new Error(`AEH_OPERATION_WORKTREE_REQUIRED: unable to create isolated worktree for ${record.id}: ${result.stderr || result.stdout || `exit ${result.exitCode}`}`);
     }
-    await trace(root, "workspace.cli.error", {
-        operationId: record.id,
-        error: "workspace id missing from CLI response"
-    });
-    return {
-        warning: "Paseo created an operation workspace but AEH could not resolve its id."
-    };
+    let workspaceId = extractWorkspaceId(result.stdout);
+    let workspaceRoot = extractWorkspacePath(result.stdout);
+    if (!workspaceId || !workspaceRoot) {
+        const list = await safeRun(run, "paseo workspace ls --json", root, 60_000);
+        if (list.exitCode === 0) {
+            workspaceId ??= findWorkspaceByBranch(list.stdout, branch)?.workspaceId;
+            workspaceRoot ??= findWorkspaceByBranch(list.stdout, branch)?.workspaceRoot;
+        }
+    }
+    if (!workspaceRoot) {
+        throw new Error(`AEH_OPERATION_WORKTREE_REQUIRED: Paseo created a worktree workspace for ${record.id} but did not expose a resolvable worktree path.`);
+    }
+    await trace(root, "workspace.cli.created", { operationId: record.id, workspaceId: workspaceId ?? "", workspaceRoot, isolation: "worktree", branch });
+    return { workspaceId, workspaceRoot };
 }
 export function extractWorkspaceId(text) {
     if (!text.trim())
@@ -321,6 +366,16 @@ export function extractWorkspaceId(text) {
         return text.match(/\b(?:workspace(?:Id)?[=: ]+)?(workspace-[A-Za-z0-9._-]+)\b/i)?.[1];
     }
 }
+export function extractWorkspacePath(text) {
+    if (!text.trim())
+        return undefined;
+    try {
+        return findWorkspacePath(JSON.parse(text));
+    }
+    catch {
+        return undefined;
+    }
+}
 function findWorkspaceId(value) {
     if (!value || typeof value !== "object")
         return undefined;
@@ -335,15 +390,8 @@ function findWorkspaceId(value) {
     const record = value;
     for (const key of ["workspaceId", "workspace_id", "id"]) {
         const candidate = record[key];
-        if (typeof candidate === "string" &&
-            candidate &&
-            (key !== "id" ||
-                /workspace/i.test(candidate) ||
-                "cwd" in record ||
-                "worktreePath" in record ||
-                "path" in record)) {
+        if (typeof candidate === "string" && candidate && (key !== "id" || /workspace/i.test(candidate) || "cwd" in record || "worktreePath" in record || "path" in record))
             return candidate;
-        }
     }
     for (const child of Object.values(record)) {
         const id = findWorkspaceId(child);
@@ -352,8 +400,99 @@ function findWorkspaceId(value) {
     }
     return undefined;
 }
-function isTerminal(status) {
-    return status === "SUCCEEDED" || status === "FAILED" || status === "CANCELLED";
+function findWorkspacePath(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const found = findWorkspacePath(item);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    const record = value;
+    for (const key of ["worktreePath", "worktree_path", "checkoutPath", "checkout_path"]) {
+        const candidate = record[key];
+        if (typeof candidate === "string" && path.isAbsolute(candidate))
+            return candidate;
+    }
+    if (String(record.isolation ?? record.isolationMode ?? "").toLowerCase().includes("worktree")) {
+        for (const key of ["path", "cwd"]) {
+            const candidate = record[key];
+            if (typeof candidate === "string" && path.isAbsolute(candidate))
+                return candidate;
+        }
+    }
+    for (const child of Object.values(record)) {
+        const found = findWorkspacePath(child);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+function findWorkspaceByBranch(text, branch) {
+    try {
+        const value = JSON.parse(text);
+        return findBranchWorkspace(value, branch);
+    }
+    catch {
+        return undefined;
+    }
+}
+function findBranchWorkspace(value, branch) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const found = findBranchWorkspace(item, branch);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    if (!value || typeof value !== "object")
+        return undefined;
+    const record = value;
+    const branchValue = [record.branch, record.branchName, record.branch_name, record.gitBranch].find((item) => typeof item === "string");
+    if (branchValue === branch)
+        return { workspaceId: findWorkspaceId(record), workspaceRoot: findWorkspacePath(record) };
+    for (const child of Object.values(record)) {
+        const found = findBranchWorkspace(child, branch);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+async function safeRun(run, command, cwd, timeoutMs) {
+    try {
+        return await run(command, { cwd, timeoutMs });
+    }
+    catch (error) {
+        return { exitCode: 1, stdout: "", stderr: String(error), durationMs: 0 };
+    }
+}
+async function loadProjectConfigIfPresent(root) {
+    try {
+        await fs.access(path.resolve(root, ".harness/project.yaml"));
+    }
+    catch {
+        return undefined;
+    }
+    return loadProjectConfig(root);
+}
+function initialIntent(kind, payload) {
+    if (kind === "audit") {
+        const audit = payload;
+        return { request: audit.request, classification: "AUDIT", risk: audit.risk, priority: 50 };
+    }
+    if (kind === "change") {
+        const change = payload;
+        return { request: change.request, classification: "CHANGE", risk: change.risk, priority: change.priority ?? 50 };
+    }
+    return { classification: "RUN", priority: payload.priority ?? 50 };
+}
+function operationPriority(payload) {
+    const value = "priority" in payload ? payload.priority : undefined;
+    return typeof value === "number" && Number.isFinite(value) ? value : 50;
 }
 function quote(value) {
     return `'${value.replaceAll("'", "'\\''")}'`;