@tea-agent/loop-agent 0.40.0-next.8 → 0.40.0

package/dist/worker/console/chat/goal-round-driver.js

@@ -0,0 +1,72 @@
+export function classifyGoalRoundAdmission(input) {
+    if (input.phase !== "active")
+        return { action: "idle", reason: "not-active" };
+    if (!input.armed)
+        return { action: "idle", reason: "disarmed" };
+    if (input.round >= input.maxRounds)
+        return { action: "idle", reason: "round-limit" };
+    if (input.hasQueuedUserTurn)
+        return { action: "wait", reason: "user-queue" };
+    if (input.hasActiveTurn || input.runtimeBusy)
+        return { action: "wait", reason: "turn-busy" };
+    if (input.operationBusy)
+        return { action: "wait", reason: "operation-busy" };
+    return { action: "ready" };
+}
+/**
+ * Small process-local wake coordinator. Durable Goal phase lives in the event
+ * stream; timers deliberately do not. A Console restart therefore cannot
+ * resume work until a human explicitly arms the Goal again.
+ */
+export class GoalRoundDriver {
+    drive;
+    waitMs;
+    timers = new Map();
+    running = new Set();
+    disposed = false;
+    constructor(drive, waitMs = 1_500) {
+        this.drive = drive;
+        this.waitMs = waitMs;
+    }
+    wake(sessionId, delayMs = 0) {
+        if (this.disposed || this.timers.has(sessionId) || this.running.has(sessionId))
+            return;
+        const timer = setTimeout(() => {
+            this.timers.delete(sessionId);
+            void this.run(sessionId);
+        }, Math.max(0, delayMs));
+        timer.unref?.();
+        this.timers.set(sessionId, timer);
+    }
+    cancel(sessionId) {
+        const timer = this.timers.get(sessionId);
+        if (timer)
+            clearTimeout(timer);
+        this.timers.delete(sessionId);
+    }
+    dispose() {
+        this.disposed = true;
+        for (const timer of this.timers.values())
+            clearTimeout(timer);
+        this.timers.clear();
+    }
+    async run(sessionId) {
+        if (this.disposed || this.running.has(sessionId))
+            return;
+        this.running.add(sessionId);
+        let retry = false;
+        try {
+            const result = await this.drive(sessionId);
+            retry = result === "wait";
+        }
+        catch {
+            // The route-level driver disarms on unsafe failures. A thrown observer or
+            // transient read must not create a hot retry loop.
+        }
+        finally {
+            this.running.delete(sessionId);
+            if (retry)
+                this.wake(sessionId, this.waitMs);
+        }
+    }
+}

package/dist/worker/console/chat/goals.js

@@ -0,0 +1,300 @@
+import { randomUUID } from "node:crypto";
+export const DEFAULT_GOAL_MAX_ROUNDS = 32;
+function cloneGoal(goal) {
+    return structuredClone(goal);
+}
+export function normalizeGoalObjective(value) {
+    if (typeof value !== "string")
+        throw new Error("objective must be a string");
+    const objective = value.replace(/\r\n/g, "\n").trim();
+    if (!objective)
+        throw new Error("objective must not be empty");
+    if (objective.length > 8_000)
+        throw new Error("objective exceeds 8000 characters");
+    return objective;
+}
+export function isExplicitGoalCreationRequest(text) {
+    const normalized = text.trim().toLowerCase();
+    return (/^\/goal(?:\s|$)/i.test(normalized) ||
+        /(创建|新建|启动|开启|设定|设置).{0,10}(持续目标|goal)/i.test(normalized) ||
+        /(create|start|set up|enable).{0,16}\bgoal\b/i.test(normalized));
+}
+export function parseGoalSnapshot(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const item = value;
+    if (item.schemaVersion !== 1 ||
+        typeof item.goalId !== "string" ||
+        !item.goalId ||
+        !Number.isSafeInteger(item.revision) ||
+        (item.revision ?? 0) < 1 ||
+        typeof item.objective !== "string" ||
+        !item.objective.trim() ||
+        !["active", "paused", "blocked", "complete"].includes(item.phase) ||
+        !Number.isSafeInteger(item.round) ||
+        (item.round ?? -1) < 0 ||
+        !Number.isSafeInteger(item.maxRounds) ||
+        (item.maxRounds ?? 0) < 1 ||
+        typeof item.createdAt !== "string" ||
+        typeof item.updatedAt !== "string") {
+        return undefined;
+    }
+    return {
+        schemaVersion: 1,
+        goalId: item.goalId,
+        revision: item.revision,
+        objective: item.objective.trim(),
+        phase: item.phase,
+        round: item.round,
+        maxRounds: item.maxRounds,
+        createdAt: item.createdAt,
+        updatedAt: item.updatedAt,
+        ...(typeof item.lastTurnId === "string" && item.lastTurnId
+            ? { lastTurnId: item.lastTurnId }
+            : {}),
+        ...(typeof item.blocker === "string" && item.blocker.trim()
+            ? { blocker: item.blocker.trim() }
+            : {}),
+    };
+}
+export function projectCurrentGoal(events) {
+    let current = null;
+    for (const event of events) {
+        if (event.kind === "goal_cleared")
+            current = null;
+        if (event.kind === "goal_changed") {
+            const parsed = parseGoalSnapshot(event.data.goal);
+            if (parsed)
+                current = parsed;
+        }
+    }
+    return current ? cloneGoal(current) : null;
+}
+export function buildGoalCompactionInstructions(rawInstructions, goal) {
+    const reminder = goal
+        ? [
+            "Preserve this durable Goal snapshot in the compaction summary. Do not mark it complete or change its phase unless the Goal tool already did so:",
+            JSON.stringify(goal),
+        ].join("\n")
+        : undefined;
+    return [rawInstructions?.trim(), reminder]
+        .filter((item) => Boolean(item))
+        .join("\n\n") || undefined;
+}
+export function buildGoalContinuationContext(goal) {
+    if (!goal)
+        return undefined;
+    return [
+        "<current_goal>",
+        "This is the durable cross-turn Goal for this session. Continue working toward its objective without broadening user authorization.",
+        JSON.stringify(goal),
+        "Use get_goal to refresh it. Use update_goal with status=complete only when the objective is genuinely achieved and no required work remains; use blocked only when safe progress cannot continue.",
+        "</current_goal>",
+    ].join("\n");
+}
+export class GoalRegistry {
+    events;
+    armed = new Set();
+    modelCreateGrants = new Set();
+    constructor(events) {
+        this.events = events;
+    }
+    get(sessionId) {
+        const goal = projectCurrentGoal(this.events.snapshot(sessionId));
+        return goal ? { ...goal, armed: this.armed.has(sessionId) } : null;
+    }
+    startTurn(sessionId, userText) {
+        if (isExplicitGoalCreationRequest(userText))
+            this.modelCreateGrants.add(sessionId);
+        else
+            this.modelCreateGrants.delete(sessionId);
+    }
+    consumeModelCreateGrant(sessionId) {
+        const granted = this.modelCreateGrants.has(sessionId);
+        this.modelCreateGrants.delete(sessionId);
+        return granted;
+    }
+    create(input) {
+        let objective;
+        try {
+            objective = normalizeGoalObjective(input.objective);
+        }
+        catch (error) {
+            return {
+                ok: false,
+                code: "GOAL_INVALID_INPUT",
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
+        const existing = this.get(input.sessionId);
+        if (existing && existing.phase !== "complete") {
+            return {
+                ok: false,
+                code: "GOAL_ALREADY_EXISTS",
+                message: "an unfinished Goal already exists for this session",
+                goal: existing,
+            };
+        }
+        const maxRounds = Number.isSafeInteger(input.maxRounds)
+            ? Math.max(1, Math.min(128, input.maxRounds))
+            : DEFAULT_GOAL_MAX_ROUNDS;
+        const now = new Date().toISOString();
+        const goal = {
+            schemaVersion: 1,
+            goalId: randomUUID(),
+            revision: 1,
+            objective,
+            phase: "active",
+            round: 0,
+            maxRounds,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.events.append(input.sessionId, input.turnId ?? `${input.sessionId}:goal`, { kind: "goal_changed", data: { goal } });
+        if (input.arm !== false)
+            this.armed.add(input.sessionId);
+        return { ok: true, goal: { ...goal, armed: this.armed.has(input.sessionId) } };
+    }
+    update(input) {
+        const current = this.get(input.sessionId);
+        if (!current)
+            return { ok: false, code: "GOAL_NOT_FOUND", message: "Goal not found" };
+        if (current.goalId !== input.goalId)
+            return {
+                ok: false,
+                code: "GOAL_ID_CONFLICT",
+                message: "Goal id does not match the current session Goal",
+                goal: current,
+            };
+        if (current.revision !== input.expectedRevision)
+            return {
+                ok: false,
+                code: "GOAL_REVISION_CONFLICT",
+                message: `Goal revision changed: expected ${input.expectedRevision}, current ${current.revision}`,
+                goal: current,
+            };
+        let objective = current.objective;
+        if (input.objective !== undefined) {
+            try {
+                objective = normalizeGoalObjective(input.objective);
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    code: "GOAL_INVALID_INPUT",
+                    message: error instanceof Error ? error.message : String(error),
+                    goal: current,
+                };
+            }
+        }
+        const phase = input.phase ?? current.phase;
+        const blocker = typeof input.blocker === "string" ? input.blocker.trim().slice(0, 2_000) : "";
+        if (phase === "blocked" && !blocker && !current.blocker) {
+            return {
+                ok: false,
+                code: "GOAL_INVALID_INPUT",
+                message: "blocked Goal requires a concrete blocker",
+                goal: current,
+            };
+        }
+        const next = {
+            ...current,
+            revision: current.revision + 1,
+            objective,
+            phase,
+            updatedAt: new Date().toISOString(),
+            ...(phase === "blocked" && blocker
+                ? { blocker }
+                : current.blocker && phase === "blocked"
+                    ? { blocker: current.blocker }
+                    : {}),
+        };
+        delete next.armed;
+        if (phase !== "blocked")
+            delete next.blocker;
+        this.events.append(input.sessionId, input.turnId ?? current.lastTurnId ?? `${input.sessionId}:goal`, { kind: "goal_changed", data: { goal: next } });
+        if (phase !== "active" || input.arm === false)
+            this.armed.delete(input.sessionId);
+        else if (input.arm === true)
+            this.armed.add(input.sessionId);
+        return { ok: true, goal: { ...next, armed: this.armed.has(input.sessionId) } };
+    }
+    beginRound(input) {
+        const current = this.get(input.sessionId);
+        if (!current)
+            return { ok: false, code: "GOAL_NOT_FOUND", message: "Goal not found" };
+        if (current.round >= current.maxRounds) {
+            this.armed.delete(input.sessionId);
+            return {
+                ok: false,
+                code: "GOAL_ROUND_LIMIT",
+                message: `Goal reached its ${current.maxRounds}-round safety limit`,
+                goal: { ...current, armed: false },
+            };
+        }
+        if (current.goalId !== input.goalId)
+            return {
+                ok: false,
+                code: "GOAL_ID_CONFLICT",
+                message: "Goal id changed before the next round started",
+                goal: current,
+            };
+        if (current.revision !== input.expectedRevision)
+            return {
+                ok: false,
+                code: "GOAL_REVISION_CONFLICT",
+                message: `Goal revision changed: expected ${input.expectedRevision}, current ${current.revision}`,
+                goal: current,
+            };
+        const next = {
+            ...current,
+            revision: current.revision + 1,
+            round: current.round + 1,
+            lastTurnId: input.turnId,
+            updatedAt: new Date().toISOString(),
+        };
+        delete next.armed;
+        this.events.append(input.sessionId, input.turnId, {
+            kind: "goal_changed",
+            data: { goal: next },
+        });
+        return { ok: true, goal: { ...next, armed: this.armed.has(input.sessionId) } };
+    }
+    clear(input) {
+        const current = this.get(input.sessionId);
+        if (!current)
+            return { ok: false, code: "GOAL_NOT_FOUND", message: "Goal not found" };
+        if (current.goalId !== input.goalId || current.revision !== input.expectedRevision) {
+            return {
+                ok: false,
+                code: current.goalId !== input.goalId
+                    ? "GOAL_ID_CONFLICT"
+                    : "GOAL_REVISION_CONFLICT",
+                message: "Goal changed before it could be cleared",
+                goal: current,
+            };
+        }
+        this.armed.delete(input.sessionId);
+        this.events.append(input.sessionId, input.turnId ?? current.lastTurnId ?? `${input.sessionId}:goal`, { kind: "goal_cleared", data: {} });
+        return { ok: true, goal: { ...current, armed: false } };
+    }
+    arm(sessionId) {
+        const goal = this.get(sessionId);
+        if (!goal || goal.phase !== "active" || goal.round >= goal.maxRounds)
+            return goal;
+        this.armed.add(sessionId);
+        return { ...goal, armed: true };
+    }
+    disarm(sessionId) {
+        this.armed.delete(sessionId);
+        const goal = this.get(sessionId);
+        return goal ? { ...goal, armed: false } : null;
+    }
+    isArmed(sessionId) {
+        return this.armed.has(sessionId);
+    }
+    clearRuntime(sessionId) {
+        this.armed.delete(sessionId);
+        this.modelCreateGrants.delete(sessionId);
+    }
+}