@elizaos/agent 2.0.0-alpha.144 → 2.0.0-alpha.151

package/packages/typescript/src/features/orchestrator/services/task-verifier-runner.js

@@ -1,372 +0,0 @@
-import { createHash } from "node:crypto";
-import { mkdir, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import path from "node:path";
-import { ModelType } from "@elizaos/core";
-import { withTrajectoryContext } from "./trajectory-context.js";
-const terminalNodeStates = new Set([
-    "completed",
-    "failed",
-    "canceled",
-    "interrupted",
-]);
-const activeVerifierRuns = new Set();
-function extractJsonBlock(raw) {
-    const trimmed = raw.trim();
-    const fenceMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
-    return (fenceMatch?.[1] ?? trimmed).trim();
-}
-function parseAcceptanceEvaluation(raw) {
-    try {
-        const parsed = JSON.parse(extractJsonBlock(raw));
-        if ((parsed.verdict !== "pass" && parsed.verdict !== "fail") ||
-            typeof parsed.summary !== "string" ||
-            parsed.summary.trim().length === 0) {
-            return null;
-        }
-        const checklist = Array.isArray(parsed.checklist)
-            ? parsed.checklist
-                .filter((entry) => Boolean(entry &&
-                typeof entry === "object" &&
-                typeof entry.criterion ===
-                    "string" &&
-                typeof entry.status === "string" &&
-                typeof entry.evidence === "string"))
-                .map((entry) => ({
-                criterion: entry.criterion.trim(),
-                status: entry.status === "pass" ||
-                    entry.status === "fail" ||
-                    entry.status === "partial"
-                    ? entry.status
-                    : "partial",
-                evidence: entry.evidence.trim(),
-            }))
-                .filter((entry) => entry.criterion.length > 0 && entry.evidence.length > 0)
-            : [];
-        return {
-            verdict: parsed.verdict,
-            summary: parsed.summary.trim(),
-            checklist,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function getVerifierRootDir() {
-    const stateDir = process.env.ELIZA_STATE_DIR?.trim() ||
-        process.env.ELIZA_STATE_DIR?.trim() ||
-        path.join(homedir(), ".eliza");
-    return path.join(stateDir, "task-verifiers");
-}
-function truncate(text, limit = 1_200) {
-    const compact = text.replace(/\s+/g, " ").trim();
-    return compact.length <= limit ? compact : `${compact.slice(0, limit)}...`;
-}
-function isVerifierReady(thread, job) {
-    if (job.status !== "pending")
-        return false;
-    if (job.verifierType !== "acceptance_criteria")
-        return false;
-    const executionNodes = thread.nodes.filter((node) => node.kind !== "goal");
-    if (executionNodes.some((node) => !terminalNodeStates.has(node.status))) {
-        return false;
-    }
-    if (!job.nodeId)
-        return true;
-    const node = thread.nodes.find((entry) => entry.id === job.nodeId);
-    return node ? terminalNodeStates.has(node.status) : false;
-}
-function collectAcceptancePrerequisiteFailures(thread) {
-    const executionNodes = thread.nodes.filter((node) => node.kind === "execution");
-    const passedCompletionVerifierNodeIds = new Set(thread.verifierJobs
-        .filter((job) => job.verifierType === "task_completion" &&
-        job.status === "passed" &&
-        typeof job.nodeId === "string")
-        .map((job) => job.nodeId));
-    const evidenceBackedNodeIds = new Set(thread.evidence
-        .filter((entry) => typeof entry.nodeId === "string" &&
-        (entry.evidenceType === "validation_summary" ||
-            entry.evidenceType === "acceptance_report"))
-        .map((entry) => entry.nodeId));
-    return {
-        failedExecutionNodes: executionNodes.filter((node) => node.status === "failed" ||
-            node.status === "canceled" ||
-            node.status === "interrupted"),
-        completedWithoutEvidence: executionNodes.filter((node) => node.status === "completed" &&
-            !passedCompletionVerifierNodeIds.has(node.id) &&
-            !evidenceBackedNodeIds.has(node.id)),
-    };
-}
-function buildDeterministicFailureEvaluation(thread, failures) {
-    if (failures.failedExecutionNodes.length > 0) {
-        return {
-            verdict: "fail",
-            summary: `Acceptance cannot pass because execution nodes failed: ${failures.failedExecutionNodes.map((node) => node.title).join(", ")}.`,
-            checklist: thread.acceptanceCriteria.map((criterion) => ({
-                criterion,
-                status: "fail",
-                evidence: `Execution nodes failed before acceptance verification completed: ${failures.failedExecutionNodes.map((node) => `${node.title}=${node.status}`).join(", ")}.`,
-            })),
-        };
-    }
-    if (failures.completedWithoutEvidence.length > 0) {
-        return {
-            verdict: "fail",
-            summary: `Acceptance cannot pass because completed execution nodes lack verification evidence: ${failures.completedWithoutEvidence.map((node) => node.title).join(", ")}.`,
-            checklist: thread.acceptanceCriteria.map((criterion) => ({
-                criterion,
-                status: "partial",
-                evidence: `Missing task-completion evidence for: ${failures.completedWithoutEvidence.map((node) => node.title).join(", ")}.`,
-            })),
-        };
-    }
-    return null;
-}
-function summarizeThreadEvidence(thread) {
-    const sessionSummaries = thread.sessions
-        .map((session) => [
-        `${session.label} [${session.framework}] status=${session.status}`,
-        session.completionSummary
-            ? `summary=${truncate(session.completionSummary, 400)}`
-            : "",
-    ]
-        .filter(Boolean)
-        .join(" | "))
-        .filter(Boolean)
-        .join("\n");
-    const decisions = thread.decisions
-        .slice(-8)
-        .map((decision) => `${decision.decision}: ${truncate(decision.reasoning, 240)}`)
-        .join("\n");
-    const artifacts = thread.artifacts
-        .slice(-12)
-        .map((artifact) => `${artifact.artifactType}: ${artifact.title}${artifact.path ? ` (${artifact.path})` : ""}`)
-        .join("\n");
-    const evidence = thread.evidence
-        .slice(-16)
-        .map((entry) => `${entry.evidenceType}: ${entry.title}${entry.summary ? ` - ${truncate(entry.summary, 220)}` : ""}`)
-        .join("\n");
-    const transcripts = thread.transcripts
-        .slice(-8)
-        .map((entry) => `${entry.direction}: ${truncate(entry.content, 240)}`)
-        .join("\n");
-    return [
-        sessionSummaries ? `Sessions\n${sessionSummaries}` : "",
-        decisions ? `Decisions\n${decisions}` : "",
-        artifacts ? `Artifacts\n${artifacts}` : "",
-        evidence ? `Evidence\n${evidence}` : "",
-        transcripts ? `Recent transcripts\n${transcripts}` : "",
-    ]
-        .filter(Boolean)
-        .join("\n\n");
-}
-async function evaluateAcceptanceCriteria(runtime, thread, job) {
-    const prompt = [
-        "You are a strict task verifier for an agent coordinator.",
-        "Decide whether the thread satisfies its acceptance criteria based only on the provided evidence.",
-        "Return JSON only with keys: verdict, summary, checklist.",
-        'Set verdict to "pass" only if every criterion is satisfied by concrete evidence.',
-        'Set verdict to "fail" if any criterion is missing, contradicted, or unsupported.',
-        "Each checklist entry must contain criterion, status (pass|fail|partial), and evidence.",
-        "",
-        `Thread title: ${thread.title}`,
-        `Original request: ${thread.originalRequest}`,
-        `Verifier job: ${job.title}`,
-        `Acceptance criteria:\n${thread.acceptanceCriteria.map((criterion, index) => `${index + 1}. ${criterion}`).join("\n")}`,
-        "",
-        `Thread evidence:\n${summarizeThreadEvidence(thread) || "No evidence recorded."}`,
-    ].join("\n");
-    const raw = await withTrajectoryContext(runtime, {
-        source: "orchestrator",
-        decisionType: "acceptance-verifier",
-        threadId: thread.id,
-        verifierJobId: job.id,
-    }, () => runtime.useModel(ModelType.TEXT_SMALL, {
-        prompt,
-        temperature: 0,
-        stream: false,
-    }));
-    const parsed = parseAcceptanceEvaluation(raw);
-    if (parsed) {
-        return parsed;
-    }
-    return {
-        verdict: "fail",
-        summary: "Acceptance verifier returned an invalid response, so the thread could not be proven complete.",
-        checklist: thread.acceptanceCriteria.map((criterion) => ({
-            criterion,
-            status: "partial",
-            evidence: "Verifier response was invalid JSON.",
-        })),
-    };
-}
-async function writeAcceptanceReport(thread, job, evaluation) {
-    const dir = path.join(getVerifierRootDir(), thread.id);
-    await mkdir(dir, { recursive: true });
-    const reportPath = path.join(dir, `${job.id}.json`);
-    const report = {
-        threadId: thread.id,
-        verifierJobId: job.id,
-        title: job.title,
-        originalRequest: thread.originalRequest,
-        acceptanceCriteria: thread.acceptanceCriteria,
-        evaluation,
-        generatedAt: new Date().toISOString(),
-    };
-    const serialized = JSON.stringify(report, null, 2);
-    await writeFile(reportPath, serialized, "utf8");
-    return {
-        reportPath,
-        sha256: createHash("sha256").update(serialized).digest("hex"),
-    };
-}
-async function finalizeAcceptanceJob(taskRegistry, thread, job, evaluation, reportPath, sha256) {
-    await taskRegistry.updateTaskVerifierJob(job.id, {
-        status: evaluation.verdict === "pass" ? "passed" : "failed",
-        completedAt: new Date().toISOString(),
-        metadata: {
-            verdict: evaluation.verdict,
-            summary: evaluation.summary,
-            reportPath,
-            sha256,
-            checklist: evaluation.checklist,
-        },
-    });
-    await taskRegistry.recordArtifact({
-        threadId: thread.id,
-        sessionId: thread.latestSessionId ?? null,
-        artifactType: "acceptance_report",
-        title: `${job.title} report`,
-        path: reportPath,
-        mimeType: "application/json",
-        metadata: {
-            verifierJobId: job.id,
-            verdict: evaluation.verdict,
-            sha256,
-        },
-    });
-    await taskRegistry.recordTaskEvidence({
-        threadId: thread.id,
-        nodeId: job.nodeId,
-        sessionId: thread.latestSessionId ?? null,
-        verifierJobId: job.id,
-        evidenceType: "acceptance_report",
-        title: job.title,
-        summary: evaluation.summary,
-        path: reportPath,
-        content: {
-            checklist: evaluation.checklist,
-            verdict: evaluation.verdict,
-        },
-        metadata: {
-            sha256,
-        },
-    });
-    await taskRegistry.appendEvent({
-        threadId: thread.id,
-        sessionId: thread.latestSessionId ?? null,
-        eventType: "verifier_job_completed",
-        summary: `${job.title} ${evaluation.verdict}`,
-        data: {
-            verifierJobId: job.id,
-            verdict: evaluation.verdict,
-            reportPath,
-        },
-    });
-    if (job.nodeId) {
-        const node = thread.nodes.find((entry) => entry.id === job.nodeId);
-        const patch = evaluation.verdict === "pass"
-            ? {
-                metadata: {
-                    acceptanceVerifierJobId: job.id,
-                    acceptanceSummary: evaluation.summary,
-                },
-            }
-            : {
-                status: "failed",
-                metadata: {
-                    acceptanceVerifierJobId: job.id,
-                    acceptanceSummary: evaluation.summary,
-                },
-            };
-        if (node) {
-            await taskRegistry.updateTaskNode(node.id, patch);
-        }
-    }
-}
-export async function runReadyTaskVerifiers(runtime, taskRegistry, threadId) {
-    let thread = await taskRegistry.getThread(threadId);
-    if (!thread) {
-        return;
-    }
-    const readyJobs = thread.verifierJobs.filter((job) => isVerifierReady(thread, job));
-    for (const job of readyJobs) {
-        if (activeVerifierRuns.has(job.id)) {
-            continue;
-        }
-        activeVerifierRuns.add(job.id);
-        try {
-            await taskRegistry.updateTaskVerifierJob(job.id, {
-                status: "running",
-                startedAt: new Date().toISOString(),
-                metadata: {
-                    source: "acceptance-runner",
-                },
-            });
-            await taskRegistry.appendEvent({
-                threadId,
-                sessionId: thread.latestSessionId ?? null,
-                eventType: "verifier_job_started",
-                summary: `Running ${job.title}`,
-                data: {
-                    verifierJobId: job.id,
-                    verifierType: job.verifierType,
-                },
-            });
-            thread = (await taskRegistry.getThread(threadId)) ?? thread;
-            const deterministicFailure = buildDeterministicFailureEvaluation(thread, collectAcceptancePrerequisiteFailures(thread));
-            const evaluation = deterministicFailure ??
-                (await evaluateAcceptanceCriteria(runtime, thread, job));
-            const report = await writeAcceptanceReport(thread, job, evaluation);
-            await finalizeAcceptanceJob(taskRegistry, thread, job, evaluation, report.reportPath, report.sha256);
-            thread = (await taskRegistry.getThread(threadId)) ?? thread;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            await taskRegistry.updateTaskVerifierJob(job.id, {
-                status: "failed",
-                completedAt: new Date().toISOString(),
-                metadata: {
-                    source: "acceptance-runner",
-                    error: message,
-                },
-            });
-            await taskRegistry.appendEvent({
-                threadId,
-                sessionId: thread.latestSessionId ?? null,
-                eventType: "verifier_job_failed",
-                summary: `${job.title} failed`,
-                data: {
-                    verifierJobId: job.id,
-                    error: message,
-                },
-            });
-            if (job.nodeId) {
-                await taskRegistry.updateTaskNode(job.nodeId, {
-                    status: "failed",
-                    metadata: {
-                        acceptanceVerifierJobId: job.id,
-                        acceptanceSummary: message,
-                    },
-                });
-            }
-        }
-        finally {
-            activeVerifierRuns.delete(job.id);
-        }
-    }
-}
-export function isTerminalTaskNodeStatus(status) {
-    return terminalNodeStates.has(status);
-}

package/packages/typescript/src/features/orchestrator/services/trajectory-context.d.ts

@@ -1,73 +0,0 @@
-/**
- * Trajectory Context — Tag orchestrator LLM calls for trajectory logging.
- *
- * Sets a lightweight context object on the runtime before `useModel()` calls
- * so the trajectory logger can identify orchestrator-specific LLM invocations
- * (coordination decisions, stall classification, idle checks, etc.) and tag
- * them with meaningful metadata instead of the generic "action" / "runtime.useModel".
- *
- * The milaidy trajectory-persistence layer reads `runtime.__orchestratorTrajectoryCtx`
- * in its `appendLlmCall` patch and writes the context into the trajectory record.
- *
- * @module services/trajectory-context
- */
-/**
- * Any runtime-like object. We accept both `AgentRuntime` and `IAgentRuntime`
- * since different call sites use different types. Using a minimal interface
- * avoids index-signature incompatibilities with ElizaOS types.
- */
-type RuntimeLike = object;
-/**
- * Orchestrator decision types that map to specific LLM call sites.
- */
-export type OrchestratorDecisionType = "coordination" | "turn-complete" | "idle-check" | "stall-classification" | "stall-classify-decide" | "swarm-context-generation" | "event-triage" | "task-validation" | "acceptance-verifier";
-export interface OrchestratorTrajectoryContext {
-    /** Source identifier — always "orchestrator" */
-    source: "orchestrator";
-    /** Which decision type triggered this LLM call */
-    decisionType: OrchestratorDecisionType;
-    /** PTY session ID of the agent being evaluated */
-    sessionId?: string;
-    /** Durable task thread identifier */
-    threadId?: string;
-    /** Acceptance verifier job identifier */
-    verifierJobId?: string;
-    /** Human-readable task label */
-    taskLabel?: string;
-    /** Repository URL or identifier (for trajectory feedback filtering) */
-    repo?: string;
-    /** Workspace directory path */
-    workdir?: string;
-    /** Original task description assigned to the agent */
-    originalTask?: string;
-}
-/**
- * Set orchestrator trajectory context on the runtime.
- * Call this before `runtime.useModel()` and clear it after.
- */
-export declare function setTrajectoryContext(runtime: RuntimeLike, ctx: OrchestratorTrajectoryContext): void;
-/**
- * Clear orchestrator trajectory context from the runtime.
- */
-export declare function clearTrajectoryContext(runtime: RuntimeLike): void;
-/**
- * Read the current orchestrator trajectory context (if any).
- * Used by the trajectory logger on the milaidy side.
- */
-export declare function readTrajectoryContext(runtime: unknown): OrchestratorTrajectoryContext | undefined;
-/**
- * Wrap a `useModel()` call with trajectory context tagging.
- * Ensures the context is always cleared, even if the call throws.
- *
- * @example
- * ```ts
- * const result = await withTrajectoryContext(
- *   ctx.runtime,
- *   { source: "orchestrator", decisionType: "coordination", sessionId },
- *   () => ctx.runtime.useModel(ModelType.TEXT_SMALL, { prompt }),
- * );
- * ```
- */
-export declare function withTrajectoryContext<T>(runtime: RuntimeLike, ctx: OrchestratorTrajectoryContext, fn: () => Promise<T>): Promise<T>;
-export {};
-//# sourceMappingURL=trajectory-context.d.ts.map

package/packages/typescript/src/features/orchestrator/services/trajectory-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trajectory-context.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/orchestrator/services/trajectory-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;GAIG;AACH,KAAK,WAAW,GAAG,MAAM,CAAC;AAE1B;;GAEG;AACH,MAAM,MAAM,wBAAwB,GACjC,cAAc,GACd,eAAe,GACf,YAAY,GACZ,sBAAsB,GACtB,uBAAuB,GACvB,0BAA0B,GAC1B,cAAc,GACd,iBAAiB,GACjB,qBAAqB,CAAC;AAEzB,MAAM,WAAW,6BAA6B;IAC7C,gDAAgD;IAChD,MAAM,EAAE,cAAc,CAAC;IACvB,kDAAkD;IAClD,YAAY,EAAE,wBAAwB,CAAC;IACvC,kDAAkD;IAClD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qCAAqC;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gCAAgC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,+BAA+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAID;;;GAGG;AACH,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,WAAW,EACpB,GAAG,EAAE,6BAA6B,GAChC,IAAI,CAEN;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAEjE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACpC,OAAO,EAAE,OAAO,GACd,6BAA6B,GAAG,SAAS,CAQ3C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,qBAAqB,CAAC,CAAC,EAC5C,OAAO,EAAE,WAAW,EACpB,GAAG,EAAE,6BAA6B,EAClC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAClB,OAAO,CAAC,CAAC,CAAC,CAOZ"}

package/packages/typescript/src/features/orchestrator/services/trajectory-context.js

@@ -1,64 +0,0 @@
-/**
- * Trajectory Context — Tag orchestrator LLM calls for trajectory logging.
- *
- * Sets a lightweight context object on the runtime before `useModel()` calls
- * so the trajectory logger can identify orchestrator-specific LLM invocations
- * (coordination decisions, stall classification, idle checks, etc.) and tag
- * them with meaningful metadata instead of the generic "action" / "runtime.useModel".
- *
- * The milaidy trajectory-persistence layer reads `runtime.__orchestratorTrajectoryCtx`
- * in its `appendLlmCall` patch and writes the context into the trajectory record.
- *
- * @module services/trajectory-context
- */
-const CTX_KEY = "__orchestratorTrajectoryCtx";
-/**
- * Set orchestrator trajectory context on the runtime.
- * Call this before `runtime.useModel()` and clear it after.
- */
-export function setTrajectoryContext(runtime, ctx) {
-    runtime[CTX_KEY] = ctx;
-}
-/**
- * Clear orchestrator trajectory context from the runtime.
- */
-export function clearTrajectoryContext(runtime) {
-    runtime[CTX_KEY] = undefined;
-}
-/**
- * Read the current orchestrator trajectory context (if any).
- * Used by the trajectory logger on the milaidy side.
- */
-export function readTrajectoryContext(runtime) {
-    if (!runtime || typeof runtime !== "object")
-        return undefined;
-    const ctx = runtime[CTX_KEY];
-    if (!ctx || typeof ctx !== "object")
-        return undefined;
-    const candidate = ctx;
-    if (candidate.source !== "orchestrator" || !candidate.decisionType)
-        return undefined;
-    return candidate;
-}
-/**
- * Wrap a `useModel()` call with trajectory context tagging.
- * Ensures the context is always cleared, even if the call throws.
- *
- * @example
- * ```ts
- * const result = await withTrajectoryContext(
- *   ctx.runtime,
- *   { source: "orchestrator", decisionType: "coordination", sessionId },
- *   () => ctx.runtime.useModel(ModelType.TEXT_SMALL, { prompt }),
- * );
- * ```
- */
-export async function withTrajectoryContext(runtime, ctx, fn) {
-    setTrajectoryContext(runtime, ctx);
-    try {
-        return await fn();
-    }
-    finally {
-        clearTrajectoryContext(runtime);
-    }
-}

package/packages/typescript/src/features/orchestrator/services/trajectory-feedback.d.ts

@@ -1,53 +0,0 @@
-/**
- * Trajectory Feedback — Past Experience Injection
- *
- * Queries the trajectory database for past orchestrator decisions and
- * formats relevant experience as agent memory context. This closes the
- * loop between trajectory *output* (logging decisions) and trajectory
- * *input* (feeding experience back to agents at spawn time).
- *
- * Inspired by "Codified Context" (arXiv:2602.20478) — known failure
- * modes and past decisions are pre-loaded into agent context so they
- * don't repeat mistakes or re-derive solutions.
- *
- * @module services/trajectory-feedback
- */
-import { type IAgentRuntime } from "@elizaos/core";
-/** A distilled experience entry from a past trajectory. */
-interface PastExperience {
-    /** When this experience was recorded */
-    timestamp: number;
-    /** The orchestrator decision type (coordination, turn-complete, etc.) */
-    decisionType: string;
-    /** Agent label that produced this experience */
-    taskLabel: string;
-    /** The key insight or decision (extracted from LLM response) */
-    insight: string;
-}
-/** Options for querying past experience. */
-export interface TrajectoryFeedbackOptions {
-    /** Maximum number of recent trajectories to scan (default: 30) */
-    maxTrajectories?: number;
-    /** Maximum number of experience entries to return (default: 8) */
-    maxEntries?: number;
-    /** Only include trajectories from the last N hours (default: 48) */
-    lookbackHours?: number;
-    /** Task description for relevance filtering */
-    taskDescription?: string;
-    /** Repository URL — only return experience from the same repo */
-    repo?: string;
-}
-/**
- * Query the trajectory database for past orchestrator decisions and
- * return distilled experience entries relevant to the current task.
- */
-export declare function queryPastExperience(runtime: IAgentRuntime, options?: TrajectoryFeedbackOptions): Promise<PastExperience[]>;
-/**
- * Format past experience entries as a markdown section suitable for
- * injection into agent memory (CLAUDE.md / GEMINI.md).
- *
- * Returns empty string if no relevant experience is found.
- */
-export declare function formatPastExperience(experiences: PastExperience[]): string;
-export {};
-//# sourceMappingURL=trajectory-feedback.d.ts.map

package/packages/typescript/src/features/orchestrator/services/trajectory-feedback.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trajectory-feedback.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/orchestrator/services/trajectory-feedback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAyB,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AAoB1E,2DAA2D;AAC3D,UAAU,cAAc;IACvB,wCAAwC;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,YAAY,EAAE,MAAM,CAAC;IACrB,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,4CAA4C;AAC5C,MAAM,WAAW,yBAAyB;IACzC,kEAAkE;IAClE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oEAAoE;IACpE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,+CAA+C;IAC/C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iEAAiE;IACjE,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AA2JD;;;GAGG;AACH,wBAAsB,mBAAmB,CACxC,OAAO,EAAE,aAAa,EACtB,OAAO,GAAE,yBAA8B,GACrC,OAAO,CAAC,cAAc,EAAE,CAAC,CA0J3B;AAID;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,cAAc,EAAE,GAAG,MAAM,CAe1E"}