@voybio/ace-swarm 0.1.0

package/dist/workspace-manager.js

@@ -0,0 +1,636 @@
+import { spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdtempSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { resolveWorkspaceArtifactPath as resolveWorkspaceArtifactPathHelper, safeRead, safeWrite, resolveWorkspaceRoot, } from "./helpers.js";
+import { storeExistsSync } from "./store/store-snapshot.js";
+import { operationalArtifactVirtualPath, writeStoreBlobsSync, } from "./store/store-artifacts.js";
+import { getRuntimeProfilePath, readRuntimeProfile } from "./runtime-profile.js";
+import { validateWorkspaceSessionRegistryPayload } from "./schemas.js";
+import { isInside, isReadError, slugify } from "./shared.js";
+import { appendStatusEvent } from "./status-events.js";
+import { buildAutonomyHookEnv, normalizeAutonomyPolicy, normalizeContinuityPolicy, } from "./ace-autonomy.js";
+export const WORKSPACE_SESSION_REGISTRY_REL_PATH = "agent-state/runtime-workspaces.json";
+const DEFAULT_MANAGED_WORKSPACE_ROOT = ".agents/ACE/.ace/workspaces";
+const DEFAULT_HOOK_TIMEOUT_MS = 15_000;
+const MAX_HOOK_TIMEOUT_MS = 60_000;
+const MIN_HOOK_TIMEOUT_MS = 1_000;
+function defaultHookState() {
+    return { status: "not_run" };
+}
+function defaultHookSummary() {
+    return {
+        after_create: defaultHookState(),
+        before_run: defaultHookState(),
+        after_run: defaultHookState(),
+        before_remove: defaultHookState(),
+    };
+}
+function defaultRegistry() {
+    return {
+        version: 1,
+        updated_at: "1970-01-01T00:00:00.000Z",
+        sessions: [],
+    };
+}
+function clampHookTimeout(input) {
+    if (!Number.isFinite(input))
+        return DEFAULT_HOOK_TIMEOUT_MS;
+    return Math.max(MIN_HOOK_TIMEOUT_MS, Math.min(MAX_HOOK_TIMEOUT_MS, Math.trunc(input)));
+}
+function emitWorkspaceEvent(eventType, summary, payload) {
+    try {
+        appendStatusEvent({
+            source_module: "capability-framework",
+            event_type: eventType,
+            status: eventType === "WORKSPACE_SESSION_CREATED" ||
+                eventType === "WORKSPACE_SESSION_REMOVED"
+                ? "done"
+                : "fail",
+            summary,
+            payload,
+        });
+    }
+    catch {
+        // Workspace lifecycle must not fail because status logging failed.
+    }
+}
+export function resolveRuntimeWorkspaceRoot(rootOverride) {
+    const workspaceRoot = resolveWorkspaceRoot();
+    const configured = rootOverride?.trim() ||
+        readRuntimeProfile().workspace.root ||
+        DEFAULT_MANAGED_WORKSPACE_ROOT;
+    return resolve(configured.startsWith("/") ? configured : resolve(workspaceRoot, configured));
+}
+function resolveTargetPath(rootPath, target) {
+    return resolve(target.startsWith("/") ? target : resolve(rootPath, target));
+}
+function canonicalizeCandidatePath(targetPath) {
+    const remainder = [];
+    let cursor = resolve(targetPath);
+    while (!existsSync(cursor)) {
+        const parent = dirname(cursor);
+        if (parent === cursor)
+            break;
+        remainder.unshift(basename(cursor));
+        cursor = parent;
+    }
+    const existing = existsSync(cursor) ? realpathSync(cursor) : cursor;
+    return resolve(existing, ...remainder);
+}
+function parseWorkspaceRegistry(raw) {
+    if (isReadError(raw))
+        return defaultRegistry();
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Workspace session registry contains invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const validation = validateWorkspaceSessionRegistryPayload(parsed);
+    if (!validation.ok) {
+        throw new Error(`Workspace session registry failed validation (${validation.schema}): ${validation.errors.join("; ")}`);
+    }
+    return parsed;
+}
+function resolveWorkspaceArtifactPath(filePath) {
+    return resolveWorkspaceArtifactPathHelper(filePath, "write");
+}
+function safeReadWorkspaceFile(filePath) {
+    return safeRead(filePath);
+}
+function safeWriteWorkspaceFile(filePath, content) {
+    return safeWrite(filePath, content);
+}
+function writeWorkspaceRegistry(registry) {
+    const validation = validateWorkspaceSessionRegistryPayload(registry);
+    if (!validation.ok) {
+        throw new Error(`Workspace session registry failed validation (${validation.schema}): ${validation.errors.join("; ")}`);
+    }
+    return safeWriteWorkspaceFile(WORKSPACE_SESSION_REGISTRY_REL_PATH, JSON.stringify(registry, null, 2));
+}
+function findSessionIndex(registry, input) {
+    if (input.session_id) {
+        return registry.sessions.findIndex((session) => session.session_id === input.session_id);
+    }
+    if (input.workspace_path) {
+        const expected = resolve(input.workspace_path);
+        return registry.sessions.findIndex((session) => resolve(session.workspace_path) === expected);
+    }
+    return -1;
+}
+function deriveWorkspacePath(rootPath, input, sessionId) {
+    if (input.workspace_path) {
+        return resolveTargetPath(rootPath, input.workspace_path);
+    }
+    const fallback = `session-${sessionId.slice(0, 8)}`;
+    const slug = slugify(input.workspace_name ?? input.objective_id ?? fallback) || fallback;
+    return resolve(rootPath, slug);
+}
+function workspaceHookStateFromResult(result) {
+    return result.detail ? { status: result.status, detail: result.detail } : { status: result.status };
+}
+function readWorkspaceRegistry() {
+    return parseWorkspaceRegistry(safeReadWorkspaceFile(WORKSPACE_SESSION_REGISTRY_REL_PATH));
+}
+export function getWorkspaceSessionRegistryPath() {
+    if (storeExistsSync(resolveWorkspaceRoot())) {
+        return operationalArtifactVirtualPath(resolveWorkspaceRoot(), WORKSPACE_SESSION_REGISTRY_REL_PATH);
+    }
+    return resolveWorkspaceArtifactPath(WORKSPACE_SESSION_REGISTRY_REL_PATH);
+}
+export function listWorkspaceSessions() {
+    return readWorkspaceRegistry();
+}
+export function validateManagedWorkspacePath(root, target, options = {}) {
+    const workspaceRoot = resolveWorkspaceRoot();
+    const canonicalWorkspaceRoot = canonicalizeCandidatePath(workspaceRoot);
+    const rootPath = resolve(root.startsWith("/") ? root : resolve(workspaceRoot, root));
+    const targetPath = resolveTargetPath(rootPath, target);
+    if (rootPath === targetPath) {
+        return {
+            ok: false,
+            code: "root_path_not_session",
+            reason: "The configured root itself is never a valid managed workspace path.",
+            root_path: rootPath,
+            target_path: targetPath,
+        };
+    }
+    if (!isInside(rootPath, targetPath)) {
+        return {
+            ok: false,
+            code: "outside_root",
+            reason: "Target path escapes the configured managed workspace root.",
+            root_path: rootPath,
+            target_path: targetPath,
+        };
+    }
+    const canonicalRootPath = canonicalizeCandidatePath(rootPath);
+    if (!options.allowExternalRoot && !isInside(canonicalWorkspaceRoot, canonicalRootPath)) {
+        return {
+            ok: false,
+            code: "root_outside_workspace",
+            reason: "Managed workspace root must resolve inside the ACE workspace root.",
+            root_path: rootPath,
+            target_path: targetPath,
+            canonical_root_path: canonicalRootPath,
+        };
+    }
+    const canonicalTargetPath = canonicalizeCandidatePath(targetPath);
+    if (!options.allowExternalRoot && !isInside(canonicalWorkspaceRoot, canonicalTargetPath)) {
+        return {
+            ok: false,
+            code: "path_outside_workspace",
+            reason: "Managed workspace target must resolve inside the ACE workspace root.",
+            root_path: rootPath,
+            target_path: targetPath,
+            canonical_root_path: canonicalRootPath,
+            canonical_target_path: canonicalTargetPath,
+        };
+    }
+    if (canonicalRootPath === canonicalTargetPath ||
+        !isInside(canonicalRootPath, canonicalTargetPath)) {
+        return {
+            ok: false,
+            code: "symlink_escape",
+            reason: "Target path escapes the managed root after canonicalization (likely via symlink traversal).",
+            root_path: rootPath,
+            target_path: targetPath,
+            canonical_root_path: canonicalRootPath,
+            canonical_target_path: canonicalTargetPath,
+        };
+    }
+    return {
+        ok: true,
+        code: "ok",
+        root_path: rootPath,
+        target_path: targetPath,
+        canonical_root_path: canonicalRootPath,
+        canonical_target_path: canonicalTargetPath,
+    };
+}
+function shouldUseEphemeralWorkspaceRoot(input) {
+    return (input.source === "executor" &&
+        !input.root &&
+        !input.workspace_path &&
+        storeExistsSync(resolveWorkspaceRoot()));
+}
+function normalizeStorePathFragment(value) {
+    return value.split("\\").join("/");
+}
+function tryDecodeUtf8(bytes) {
+    try {
+        const decoder = new TextDecoder("utf-8", { fatal: true });
+        return {
+            encoding: "utf8",
+            content: decoder.decode(bytes),
+        };
+    }
+    catch {
+        return {
+            encoding: "base64",
+            content: bytes.toString("base64"),
+        };
+    }
+}
+function listWorkspaceFiles(rootPath) {
+    if (!existsSync(rootPath))
+        return [];
+    const entries = [];
+    const walk = (cursor) => {
+        for (const item of readdirSync(cursor, { withFileTypes: true })) {
+            const fullPath = resolve(cursor, item.name);
+            if (item.isDirectory()) {
+                walk(fullPath);
+            }
+            else if (item.isFile()) {
+                entries.push(fullPath);
+            }
+        }
+    };
+    walk(rootPath);
+    return entries.sort((a, b) => a.localeCompare(b));
+}
+function captureWorkspaceToStore(session) {
+    const workspaceRoot = resolveWorkspaceRoot();
+    if (!storeExistsSync(workspaceRoot) || !existsSync(session.workspace_path)) {
+        return undefined;
+    }
+    const baseKey = `state/runtime/workspaces/sessions/${session.session_id}`;
+    const files = listWorkspaceFiles(session.workspace_path);
+    const manifestFiles = [];
+    const blobs = [];
+    for (const filePath of files) {
+        const relPath = normalizeStorePathFragment(relative(session.workspace_path, filePath));
+        const key = `${baseKey}/files/${relPath}`;
+        const raw = readFileSync(filePath);
+        const decoded = tryDecodeUtf8(raw);
+        blobs.push({ key, content: decoded.content });
+        manifestFiles.push({
+            path: relPath,
+            key,
+            encoding: decoded.encoding,
+            size_bytes: raw.length,
+        });
+    }
+    const manifestKey = `${baseKey}/manifest.json`;
+    const manifest = {
+        version: 1,
+        captured_at: new Date().toISOString(),
+        session_id: session.session_id,
+        source: session.source,
+        status: session.status,
+        original_workspace_path: session.workspace_path,
+        original_root_path: session.root_path,
+        files: manifestFiles,
+    };
+    blobs.push({ key: manifestKey, content: JSON.stringify(manifest, null, 2) });
+    const written = writeStoreBlobsSync(workspaceRoot, blobs);
+    const storePath = (written[0] ?? "").split("#")[0];
+    return {
+        workspace_path: `${storePath}#${baseKey}`,
+        root_path: `${storePath}#${baseKey}`,
+        manifest_path: written[written.length - 1] ??
+            `${storePath}#${manifestKey}`,
+        file_count: manifestFiles.length,
+    };
+}
+export function runWorkspaceHook(kind, session, timeoutMs) {
+    const runtimeProfile = readRuntimeProfile();
+    const command = runtimeProfile.workspace.hooks[kind];
+    if (!command) {
+        return {
+            ok: true,
+            kind,
+            status: "not_run",
+            command: null,
+            detail: "Hook not configured.",
+        };
+    }
+    const timeout = clampHookTimeout(timeoutMs);
+    const hookCwd = existsSync(session.workspace_path)
+        ? session.workspace_path
+        : session.root_path;
+    const result = spawnSync("sh", ["-c", command], {
+        cwd: hookCwd,
+        encoding: "utf-8",
+        timeout,
+        maxBuffer: 4 * 1024 * 1024,
+        env: {
+            ...process.env,
+            ACE_RUNTIME_PROFILE_PATH: getRuntimeProfilePath(),
+            ACE_WORKSPACE_SESSION_ID: session.session_id,
+            ACE_WORKSPACE_SESSION_PATH: session.workspace_path,
+            ACE_WORKSPACE_SESSION_ROOT: session.root_path,
+            ACE_WORKSPACE_HOOK_KIND: kind,
+            ...buildAutonomyHookEnv(normalizeAutonomyPolicy(runtimeProfile.autonomy), normalizeContinuityPolicy(runtimeProfile.continuity)),
+        },
+    });
+    const output = ((result.stdout ?? "") + (result.stderr ?? "")).trim().slice(0, 4000);
+    const timedOut = result.signal === "SIGTERM" && result.status === null;
+    if (result.error || timedOut || result.status !== 0) {
+        return {
+            ok: false,
+            kind,
+            status: "failed",
+            command,
+            exit_code: result.status,
+            timed_out: timedOut,
+            detail: output ||
+                result.error?.message ||
+                `Hook exited with status ${result.status ?? "unknown"}`,
+        };
+    }
+    return {
+        ok: true,
+        kind,
+        status: "ok",
+        command,
+        exit_code: result.status,
+        detail: output || "Hook completed successfully.",
+    };
+}
+export function createWorkspaceSession(input) {
+    const registryPath = getWorkspaceSessionRegistryPath();
+    const sessionId = input.session_id?.trim() || randomUUID();
+    const now = new Date().toISOString();
+    let registry;
+    try {
+        registry = readWorkspaceRegistry();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        emitWorkspaceEvent("WORKSPACE_SESSION_FAILED", "Workspace session create failed because the registry could not be read.", { error: message });
+        return { ok: false, registry_path: registryPath, error: message };
+    }
+    const useEphemeralRoot = shouldUseEphemeralWorkspaceRoot(input);
+    const rootPath = useEphemeralRoot
+        ? mkdtempSync(join(tmpdir(), "ace-runtime-workspaces-"))
+        : resolveRuntimeWorkspaceRoot(input.root);
+    const workspacePath = deriveWorkspacePath(rootPath, input, sessionId);
+    const validation = validateManagedWorkspacePath(rootPath, workspacePath, {
+        allowExternalRoot: useEphemeralRoot,
+    });
+    if (!validation.ok) {
+        emitWorkspaceEvent("WORKSPACE_SESSION_FAILED", `Workspace session create rejected for ${workspacePath}`, { validation });
+        return {
+            ok: false,
+            registry_path: registryPath,
+            error: validation.reason,
+            validation,
+        };
+    }
+    const duplicate = registry.sessions.find((session) => resolve(session.workspace_path) === validation.target_path &&
+        session.status !== "archived" &&
+        session.status !== "removed");
+    if (duplicate) {
+        const error = `Workspace path is already managed by session ${duplicate.session_id}.`;
+        emitWorkspaceEvent("WORKSPACE_SESSION_FAILED", error, { session_id: duplicate.session_id, workspace_path: duplicate.workspace_path });
+        return { ok: false, registry_path: registryPath, error, validation };
+    }
+    if (existsSync(validation.target_path)) {
+        const error = `Workspace path already exists and cannot be claimed: ${validation.target_path}`;
+        emitWorkspaceEvent("WORKSPACE_SESSION_FAILED", error, {
+            workspace_path: validation.target_path,
+        });
+        return { ok: false, registry_path: registryPath, error, validation };
+    }
+    mkdirSync(validation.root_path, { recursive: true });
+    mkdirSync(validation.target_path, { recursive: true });
+    const session = {
+        session_id: sessionId,
+        workspace_path: validation.target_path,
+        root_path: validation.root_path,
+        status: "active",
+        source: input.source,
+        objective_id: input.objective_id,
+        tracker_item_id: input.tracker_item_id,
+        created_at: now,
+        updated_at: now,
+        hooks: defaultHookSummary(),
+    };
+    const hookResult = runWorkspaceHook("after_create", session, input.hooks_timeout_ms);
+    session.hooks.after_create = workspaceHookStateFromResult(hookResult);
+    if (!hookResult.ok) {
+        session.status = "failed";
+        session.last_error = hookResult.detail;
+    }
+    registry.sessions.push(session);
+    registry.updated_at = now;
+    writeWorkspaceRegistry(registry);
+    if (!hookResult.ok) {
+        emitWorkspaceEvent("WORKSPACE_HOOK_FAILED", `Workspace hook after_create failed for ${session.session_id}`, {
+            session_id: session.session_id,
+            workspace_path: session.workspace_path,
+            detail: hookResult.detail,
+        });
+        emitWorkspaceEvent("WORKSPACE_SESSION_FAILED", `Workspace session ${session.session_id} created with failed after_create hook.`, {
+            session_id: session.session_id,
+            workspace_path: session.workspace_path,
+            detail: hookResult.detail,
+        });
+        return {
+            ok: false,
+            registry_path: registryPath,
+            session,
+            error: hookResult.detail ?? "after_create hook failed",
+            validation,
+        };
+    }
+    emitWorkspaceEvent("WORKSPACE_SESSION_CREATED", `Workspace session ${session.session_id} created.`, {
+        session_id: session.session_id,
+        workspace_path: session.workspace_path,
+        root_path: session.root_path,
+        source: session.source,
+    });
+    return { ok: true, registry_path: registryPath, session, validation };
+}
+export function removeWorkspaceSession(input) {
+    const registryPath = getWorkspaceSessionRegistryPath();
+    const now = new Date().toISOString();
+    let registry;
+    try {
+        registry = readWorkspaceRegistry();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        emitWorkspaceEvent("WORKSPACE_SESSION_FAILED", "Workspace session removal failed because the registry could not be read.", { error: message });
+        return { ok: false, registry_path: registryPath, error: message };
+    }
+    const sessionIndex = findSessionIndex(registry, input);
+    if (sessionIndex === -1) {
+        const error = "Removal only applies to managed workspace sessions already present in the registry.";
+        emitWorkspaceEvent("WORKSPACE_SESSION_FAILED", error, {
+            session_id: input.session_id,
+            workspace_path: input.workspace_path,
+        });
+        return { ok: false, registry_path: registryPath, error };
+    }
+    const session = registry.sessions[sessionIndex];
+    const expectedRootPath = resolveRuntimeWorkspaceRoot(input.root ?? session.root_path);
+    const allowExternalRoot = storeExistsSync(resolveWorkspaceRoot()) &&
+        !isInside(canonicalizeCandidatePath(resolveWorkspaceRoot()), canonicalizeCandidatePath(expectedRootPath));
+    const validation = validateManagedWorkspacePath(expectedRootPath, session.workspace_path, { allowExternalRoot });
+    if (!validation.ok) {
+        emitWorkspaceEvent("WORKSPACE_SESSION_FAILED", `Workspace session removal rejected for ${session.session_id}`, { session_id: session.session_id, validation });
+        return {
+            ok: false,
+            registry_path: registryPath,
+            session,
+            error: validation.reason,
+            validation,
+        };
+    }
+    const hookResult = runWorkspaceHook("before_remove", session, input.hooks_timeout_ms);
+    session.hooks.before_remove = workspaceHookStateFromResult(hookResult);
+    session.updated_at = now;
+    if (!hookResult.ok) {
+        session.status = "failed";
+        session.last_error = hookResult.detail;
+        registry.updated_at = now;
+        writeWorkspaceRegistry(registry);
+        emitWorkspaceEvent("WORKSPACE_HOOK_FAILED", `Workspace hook before_remove failed for ${session.session_id}`, {
+            session_id: session.session_id,
+            workspace_path: session.workspace_path,
+            detail: hookResult.detail,
+        });
+        emitWorkspaceEvent("WORKSPACE_SESSION_FAILED", `Workspace session ${session.session_id} removal aborted by hook failure.`, {
+            session_id: session.session_id,
+            workspace_path: session.workspace_path,
+            detail: hookResult.detail,
+        });
+        return {
+            ok: false,
+            registry_path: registryPath,
+            session,
+            error: hookResult.detail ?? "before_remove hook failed",
+            validation,
+        };
+    }
+    const retention = readRuntimeProfile().workspace.retention;
+    const captured = captureWorkspaceToStore(session);
+    if (retention === "archive" && !captured) {
+        const archivePath = resolve(validation.root_path, ".archive", session.session_id);
+        const archiveValidation = validateManagedWorkspacePath(validation.root_path, archivePath, { allowExternalRoot });
+        if (!archiveValidation.ok) {
+            session.status = "failed";
+            session.last_error = archiveValidation.reason;
+            registry.updated_at = now;
+            writeWorkspaceRegistry(registry);
+            emitWorkspaceEvent("WORKSPACE_SESSION_FAILED", `Archive target rejected for workspace session ${session.session_id}`, { session_id: session.session_id, validation: archiveValidation });
+            return {
+                ok: false,
+                registry_path: registryPath,
+                session,
+                error: archiveValidation.reason,
+                validation: archiveValidation,
+            };
+        }
+        if (existsSync(validation.target_path)) {
+            mkdirSync(dirname(archiveValidation.target_path), { recursive: true });
+            renameSync(validation.target_path, archiveValidation.target_path);
+        }
+        session.workspace_path = archiveValidation.target_path;
+        session.status = "archived";
+    }
+    else {
+        if (existsSync(validation.target_path)) {
+            rmSync(validation.target_path, { recursive: true, force: false });
+        }
+        session.workspace_path = captured?.workspace_path ?? session.workspace_path;
+        session.root_path = captured?.root_path ?? session.root_path;
+        session.status = retention === "archive" ? "archived" : "removed";
+    }
+    if (allowExternalRoot && existsSync(validation.root_path)) {
+        try {
+            if (readdirSync(validation.root_path).length === 0) {
+                rmSync(validation.root_path, { recursive: false, force: false });
+            }
+        }
+        catch {
+            // Best-effort cleanup for ephemeral temp roots.
+        }
+    }
+    session.updated_at = now;
+    delete session.last_error;
+    registry.updated_at = now;
+    writeWorkspaceRegistry(registry);
+    emitWorkspaceEvent("WORKSPACE_SESSION_REMOVED", `Workspace session ${session.session_id} ${session.status}.`, {
+        session_id: session.session_id,
+        workspace_path: session.workspace_path,
+        status: session.status,
+    });
+    return { ok: true, registry_path: registryPath, session, validation };
+}
+export function runWorkspaceSessionHook(input) {
+    const registryPath = getWorkspaceSessionRegistryPath();
+    const now = new Date().toISOString();
+    let registry;
+    try {
+        registry = readWorkspaceRegistry();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            ok: false,
+            registry_path: registryPath,
+            hook: {
+                ok: false,
+                kind: input.kind,
+                status: "failed",
+                detail: message,
+            },
+            error: message,
+        };
+    }
+    const sessionIndex = findSessionIndex(registry, input);
+    if (sessionIndex === -1) {
+        const error = "Hook execution only applies to managed workspace sessions already present in the registry.";
+        return {
+            ok: false,
+            registry_path: registryPath,
+            hook: {
+                ok: false,
+                kind: input.kind,
+                status: "failed",
+                detail: error,
+            },
+            error,
+        };
+    }
+    const session = registry.sessions[sessionIndex];
+    const hookResult = runWorkspaceHook(input.kind, session, input.hooks_timeout_ms);
+    session.hooks[input.kind] = workspaceHookStateFromResult(hookResult);
+    session.updated_at = now;
+    if (!hookResult.ok) {
+        session.status = "failed";
+        session.last_error = hookResult.detail;
+    }
+    else if (session.status === "failed" && session.last_error === hookResult.detail) {
+        delete session.last_error;
+    }
+    registry.updated_at = now;
+    writeWorkspaceRegistry(registry);
+    if (!hookResult.ok) {
+        emitWorkspaceEvent("WORKSPACE_HOOK_FAILED", `Workspace hook ${input.kind} failed for ${session.session_id}`, {
+            session_id: session.session_id,
+            workspace_path: session.workspace_path,
+            detail: hookResult.detail,
+        });
+        emitWorkspaceEvent("WORKSPACE_SESSION_FAILED", `Workspace session ${session.session_id} recorded failed hook ${input.kind}.`, {
+            session_id: session.session_id,
+            workspace_path: session.workspace_path,
+            detail: hookResult.detail,
+        });
+    }
+    return {
+        ok: hookResult.ok,
+        registry_path: registryPath,
+        session,
+        hook: hookResult,
+        error: hookResult.ok ? undefined : hookResult.detail,
+    };
+}
+//# sourceMappingURL=workspace-manager.js.map