@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/worker/console/interview/grill-me.js

@@ -0,0 +1,277 @@
+/**
+ * Deterministic grill-me Requirement Interview engine (design §7.8).
+ * One open question at a time; Draft updates from answers; integrity
+ * assessment when required fields are present.
+ */
+import { consoleWorkflowKindPromptList, normalizeConsoleWorkflowKind, } from "../workflow-kinds.js";
+import { classifyTaskDemand, } from "../../../task/task-demand-routing.js";
+const GAP_ORDER = [
+    "objective",
+    "scope",
+    "nonGoals",
+    "acceptanceCriteria",
+    "allowedPaths",
+    "taskKind",
+    "forbiddenPaths",
+    "verifyCommands",
+];
+function requirementMarkdownFromDraft(draft) {
+    const requirement = draft.requirement ?? {};
+    return [
+        "# 需求",
+        requirement.objective ?? "",
+        ...(requirement.scope ?? []),
+        ...(requirement.acceptanceCriteria ?? []).map((item) => `${item.id}: ${item.text}`),
+        "## 非目标",
+        ...(requirement.nonGoals ?? []),
+    ].join("\n");
+}
+export function recommendTaskKindForDraft(draft, context = {}) {
+    const classification = classifyTaskDemand({
+        title: draft.title,
+        requirementMarkdown: requirementMarkdownFromDraft(draft),
+        allowedPaths: draft.constraints?.allowedPaths ?? [],
+        frontendProject: context.frontendProject,
+    });
+    return classification.kind === "frontend"
+        ? "frontend-implementation"
+        : "standard";
+}
+function hasText(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function hasItems(value) {
+    return Array.isArray(value) && value.length > 0;
+}
+export function listDraftGaps(draft) {
+    const gaps = [];
+    const req = draft.requirement ?? {};
+    if (!hasText(req.objective))
+        gaps.push("objective");
+    if (!hasItems(req.scope))
+        gaps.push("scope");
+    if (!hasItems(req.nonGoals))
+        gaps.push("nonGoals");
+    if (!hasItems(req.acceptanceCriteria))
+        gaps.push("acceptanceCriteria");
+    if (!hasText(draft.taskKind))
+        gaps.push("taskKind");
+    if (!hasItems(draft.constraints?.allowedPaths))
+        gaps.push("allowedPaths");
+    if (!hasItems(draft.constraints?.forbiddenPaths))
+        gaps.push("forbiddenPaths");
+    if (!hasItems(draft.verification?.commands))
+        gaps.push("verifyCommands");
+    return gaps;
+}
+export function isDraftStructurallyComplete(draft) {
+    return listDraftGaps(draft).length === 0;
+}
+export function buildQuestionForGap(gapId, draft, context = {}) {
+    const taskId = draft.taskId;
+    const questions = {
+        objective: {
+            id: `q-${gapId}`,
+            gapId,
+            text: `任务 ${taskId} 的核心目标（objective）是什么？请用一句话说明要交付什么。`,
+            recommendation: `实现并验证 ${taskId} 的明确、可验收交付物`,
+            affectsFields: ["requirement.objective"],
+            risk: "high",
+        },
+        scope: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "本轮允许改动的范围（scope）是哪些路径/模块？用逗号或换行列出。",
+            // No product-template default — must come from PRD intake or human override.
+            recommendation: "（请按 PRD / 仓库结构填写；勿套用 Console 模板路径）",
+            affectsFields: ["requirement.scope"],
+            risk: "high",
+        },
+        nonGoals: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "明确非目标（non-goals）是什么？本轮刻意不做哪些事？",
+            recommendation: "（本轮明确不做的事项；可写「暂无」）",
+            affectsFields: ["requirement.nonGoals"],
+            risk: "medium",
+        },
+        acceptanceCriteria: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "验收标准有哪些？可用分号或换行列出（将编号为 AC-1…）。",
+            recommendation: "（请写可观测验收标准；勿套用产品模板 AC）",
+            affectsFields: ["requirement.acceptanceCriteria"],
+            risk: "high",
+        },
+        taskKind: {
+            id: `q-${gapId}`,
+            gapId,
+            text: `流程类型（taskKind）应设为？(${consoleWorkflowKindPromptList()})`,
+            recommendation: recommendTaskKindForDraft(draft, context),
+            affectsFields: ["taskKind"],
+            risk: "medium",
+        },
+        allowedPaths: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "结构化 allowedPaths（写入白名单）？逗号/换行分隔 glob。",
+            recommendation: "（工程边界须人类确认；示例：src/**, test/**）",
+            affectsFields: ["constraints.allowedPaths"],
+            risk: "high",
+        },
+        forbiddenPaths: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "forbiddenPaths（禁止写入）？逗号/换行分隔。",
+            recommendation: ".harness/**, node_modules/**, package.json",
+            affectsFields: ["constraints.forbiddenPaths"],
+            risk: "high",
+        },
+        verifyCommands: {
+            id: `q-${gapId}`,
+            gapId,
+            text: "验证命令（verifyCommands）？可给一条或多条 shell（换行分隔）。",
+            recommendation: "npm run typecheck",
+            affectsFields: ["verification.commands"],
+            risk: "medium",
+        },
+    };
+    return questions[gapId];
+}
+export function nextGrillMeQuestion(draft, context = {}) {
+    const gaps = listDraftGaps(draft);
+    for (const gapId of GAP_ORDER) {
+        if (gaps.includes(gapId))
+            return buildQuestionForGap(gapId, draft, context);
+    }
+    return undefined;
+}
+function splitList(text) {
+    return text
+        .split(/[\n,;，；]+/)
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+function resolveAnswerText(response, recommendation, text) {
+    if (response === "accept-recommendation")
+        return recommendation;
+    if (response === "defer")
+        return text?.trim() || recommendation;
+    return (text ?? "").trim() || recommendation;
+}
+/**
+ * Apply one grill-me answer onto Draft. Returns updated draft (immutable merge).
+ */
+export function applyGrillMeAnswer(draft, question, answer) {
+    const value = resolveAnswerText(answer.response, question.recommendation, answer.text);
+    const next = {
+        ...draft,
+        requirement: { ...draft.requirement },
+        constraints: {
+            invariants: draft.constraints?.invariants ?? [],
+            allowedPaths: draft.constraints?.allowedPaths ?? [],
+            forbiddenPaths: draft.constraints?.forbiddenPaths ?? [],
+            ...draft.constraints,
+        },
+        verification: {
+            commands: draft.verification?.commands ?? [],
+            ...draft.verification,
+        },
+    };
+    switch (question.gapId) {
+        case "objective":
+            next.requirement = { ...next.requirement, objective: value };
+            break;
+        case "scope":
+            next.requirement = { ...next.requirement, scope: splitList(value) };
+            break;
+        case "nonGoals":
+            next.requirement = { ...next.requirement, nonGoals: splitList(value) };
+            break;
+        case "acceptanceCriteria":
+            next.requirement = {
+                ...next.requirement,
+                acceptanceCriteria: splitList(value).map((text, i) => ({
+                    id: `AC-${i + 1}`,
+                    text,
+                })),
+            };
+            break;
+        case "taskKind":
+            next.taskKind = normalizeConsoleWorkflowKind(value, "standard");
+            break;
+        case "allowedPaths":
+            next.constraints = {
+                ...next.constraints,
+                allowedPaths: splitList(value),
+            };
+            break;
+        case "forbiddenPaths":
+            next.constraints = {
+                ...next.constraints,
+                forbiddenPaths: splitList(value),
+            };
+            break;
+        case "verifyCommands":
+            next.verification = {
+                ...next.verification,
+                commands: splitList(value).map((command, i) => ({
+                    label: `verify-${i + 1}`,
+                    command,
+                    timeoutMs: 120_000,
+                })),
+            };
+            break;
+    }
+    if (answer.response === "defer" && question.risk !== "high") {
+        const assumptions = Array.isArray(draft.assumptions)
+            ? [...draft.assumptions]
+            : [];
+        assumptions.push({
+            questionId: question.id,
+            gapId: question.gapId,
+            assumed: value,
+            at: new Date().toISOString(),
+        });
+        next.assumptions = assumptions;
+    }
+    return next;
+}
+export function emptyDraft(taskId, title, options) {
+    const taskKind = options?.taskKind?.trim()
+        ? normalizeConsoleWorkflowKind(options.taskKind, "standard")
+        : undefined;
+    return {
+        schemaVersion: 1,
+        taskId,
+        title: title?.trim() || taskId,
+        taskKind,
+        requirement: {},
+        constraints: {
+            invariants: [],
+            allowedPaths: [],
+            forbiddenPaths: [],
+        },
+        verification: {
+            commands: [],
+        },
+        openQuestions: [],
+        assumptions: [],
+    };
+}
+export function draftSummary(draft) {
+    return {
+        taskId: draft.taskId,
+        title: draft.title,
+        taskKind: draft.taskKind ?? null,
+        objective: draft.requirement?.objective ?? null,
+        scope: draft.requirement?.scope ?? [],
+        nonGoals: draft.requirement?.nonGoals ?? [],
+        acceptanceCriteria: draft.requirement?.acceptanceCriteria ?? [],
+        allowedPaths: draft.constraints?.allowedPaths ?? [],
+        forbiddenPaths: draft.constraints?.forbiddenPaths ?? [],
+        verifyCommands: draft.verification?.commands ?? [],
+        gaps: listDraftGaps(draft),
+        structurallyComplete: isDraftStructurallyComplete(draft),
+    };
+}

package/dist/worker/console/interview/session.js

@@ -0,0 +1,100 @@
+import { randomBytes } from "node:crypto";
+import path from "node:path";
+import { readJsonIfExists, writeSecureJson, } from "../app-data.js";
+import { createInterviewResourceLoader, } from "./tools.js";
+function sessionPath(appData, sessionId) {
+    return path.join(appData.interviews, `${sessionId}.json`);
+}
+export function newInterviewSessionId() {
+    return `iv_${randomBytes(12).toString("hex")}`;
+}
+export class InterviewSessionStore {
+    appData;
+    loader;
+    constructor(appData) {
+        this.appData = appData;
+        this.loader = createInterviewResourceLoader();
+    }
+    async get(sessionId) {
+        return readJsonIfExists(sessionPath(this.appData, sessionId));
+    }
+    async create(input) {
+        const now = new Date().toISOString();
+        const session = {
+            schemaVersion: 1,
+            sessionId: newInterviewSessionId(),
+            taskId: input.taskId,
+            state: "not-started",
+            operatorSessionId: input.operatorSessionId,
+            createdAt: now,
+            updatedAt: now,
+            answers: [],
+            instructionVersion: input.instructionVersion ?? "grill-me@1",
+        };
+        await writeSecureJson(sessionPath(this.appData, session.sessionId), session);
+        return session;
+    }
+    async save(session) {
+        const next = { ...session, updatedAt: new Date().toISOString() };
+        await writeSecureJson(sessionPath(this.appData, next.sessionId), next);
+        return next;
+    }
+    /**
+     * grill-me: open exactly one question (or clear when complete).
+     */
+    async setCurrentQuestion(sessionId, question, state = "eliciting") {
+        const session = await this.get(sessionId);
+        if (!session)
+            throw new Error(`interview session not found: ${sessionId}`);
+        return this.save({
+            ...session,
+            currentQuestion: question,
+            state: question ? state : session.state,
+        });
+    }
+    async recordAnswer(sessionId, answer) {
+        const session = await this.get(sessionId);
+        if (!session)
+            throw new Error(`interview session not found: ${sessionId}`);
+        if (session.currentQuestion &&
+            session.currentQuestion.id !== answer.questionId) {
+            throw new Error("answer does not match current open question");
+        }
+        return this.save({
+            ...session,
+            answers: [...session.answers, answer],
+            currentQuestion: undefined,
+            state: "awaiting-user-answer",
+        });
+    }
+    async markDraftReady(sessionId, draft, draftSha256) {
+        const session = await this.get(sessionId);
+        if (!session)
+            throw new Error(`interview session not found: ${sessionId}`);
+        if (session.taskId !== draft.taskId) {
+            throw new Error("draft taskId does not match interview session");
+        }
+        return this.save({
+            ...session,
+            state: "draft-ready",
+            draftSha256,
+            currentQuestion: undefined,
+        });
+    }
+    async markAwaitingConfirmation(sessionId, assessmentId) {
+        const session = await this.get(sessionId);
+        if (!session)
+            throw new Error(`interview session not found: ${sessionId}`);
+        return this.save({
+            ...session,
+            state: "awaiting-confirmation",
+            assessmentId,
+        });
+    }
+    async markApplied(sessionId) {
+        const session = await this.get(sessionId);
+        if (!session)
+            throw new Error(`interview session not found: ${sessionId}`);
+        return this.save({ ...session, state: "applied" });
+    }
+}

package/dist/worker/console/interview/tools.js

@@ -0,0 +1,109 @@
+/**
+ * Requirement Interview closed tool registry (design §7.5).
+ * Server-side enforcement only — UI hiding is not enough.
+ */
+export const INTERVIEW_ALLOWED_TOOLS = Object.freeze([
+    "draft_read",
+    "draft_update",
+    "contract_validate",
+    "contract_diff",
+    "repo_explore_readonly",
+    "reference_read",
+]);
+/** Explicit denials for mutation / coding tools (AC-C2-02). */
+export const INTERVIEW_DENIED_TOOLS = Object.freeze([
+    "edit",
+    "write",
+    "bash",
+    "shell",
+    "full-tools",
+    "full_tools",
+    "apply_patch",
+    "apply-patch",
+    "contractApply",
+    "contract_apply",
+    "runDag",
+    "run_dag",
+    "reconcile",
+    "dagAbandon",
+    "dag_approve",
+    "dagApprove",
+    "dagReject",
+    "dagResume",
+    "importPrd",
+    "newTask",
+    "contractAdopt",
+]);
+const ALLOWED = new Set(INTERVIEW_ALLOWED_TOOLS.map((t) => t.toLowerCase()));
+const DENIED = new Set(INTERVIEW_DENIED_TOOLS.map((t) => t.toLowerCase()));
+export function isInterviewToolAllowed(toolId) {
+    return ALLOWED.has(toolId.trim().toLowerCase());
+}
+export function isInterviewToolDenied(toolId) {
+    const id = toolId.trim().toLowerCase();
+    if (DENIED.has(id))
+        return true;
+    // normalize snake/camel: contractApply already listed; catch run-dag variants
+    const compact = id.replace(/[-_]/g, "");
+    for (const d of DENIED) {
+        if (d.replace(/[-_]/g, "") === compact)
+            return true;
+    }
+    return false;
+}
+/**
+ * Gate 1/2/3: session create, setActiveTools, and each tool call.
+ */
+export function authorizeInterviewTool(toolId) {
+    const id = toolId.trim();
+    if (!id) {
+        return {
+            ok: false,
+            code: "tool-denied",
+            toolId: id,
+            message: "empty tool id is not allowed in Requirement Interview",
+        };
+    }
+    if (isInterviewToolDenied(id) || !isInterviewToolAllowed(id)) {
+        return {
+            ok: false,
+            code: "tool-denied",
+            toolId: id,
+            message: `tool "${id}" is not permitted in Requirement Interview (no contractApply/runDag/reconcile/edit/write/bash)`,
+        };
+    }
+    return { ok: true, toolId: id };
+}
+export function filterActiveInterviewTools(requested) {
+    const allowed = [];
+    const denied = [];
+    for (const toolId of requested) {
+        const decision = authorizeInterviewTool(toolId);
+        if (decision.ok)
+            allowed.push(decision.toolId);
+        else
+            denied.push(toolId);
+    }
+    return { allowed, denied };
+}
+export function createInterviewResourceLoader() {
+    let active = new Set();
+    return {
+        mode: "requirement-interview",
+        allowedToolIds: INTERVIEW_ALLOWED_TOOLS,
+        deniedToolIds: INTERVIEW_DENIED_TOOLS,
+        listTools: () => INTERVIEW_ALLOWED_TOOLS,
+        tryActivateTool: (toolId) => {
+            const decision = authorizeInterviewTool(toolId);
+            if (decision.ok)
+                active.add(decision.toolId);
+            return decision;
+        },
+        setActiveToolsByName: (names) => {
+            const { allowed, denied } = filterActiveInterviewTools(names);
+            active = new Set(allowed);
+            return { active: [...active], denied };
+        },
+        allowsEnvToolRestore: false,
+    };
+}

package/dist/worker/console/loopback.js

@@ -0,0 +1,16 @@
+/**
+ * Console-local loopback host check.
+ * Used for default bind safety messaging and mutation Host checks on loopback binds.
+ */
+export function isLoopbackHost(host) {
+    const normalized = host.trim().toLowerCase();
+    if (!normalized)
+        return false;
+    if (normalized === "localhost" ||
+        normalized === "::1" ||
+        normalized === "[::1]") {
+        return true;
+    }
+    // 127.0.0.0/8
+    return /^127(?:\.\d{1,3}){3}$/.test(normalized);
+}

package/dist/worker/console/mutation-gate-receipt-store.js

@@ -0,0 +1,184 @@
+/**
+ * Lightweight Human Gate receipts for mutation actions that are not DAG-bound
+ * (standaloneTaskRerun / workerTaskRetry). Mirrors contract-apply receipt
+ * semantics with an atomic prepared → dispatching → dispatched state machine
+ * so concurrent confirm POSTs cannot create duplicate operations.
+ */
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+export class MutationGateReceiptStore {
+    dir;
+    constructor(appData) {
+        this.dir = path.join(appData.root, "mutation-gate-receipts");
+    }
+    file(id) {
+        return path.join(this.dir, `${id.replace(/[^a-zA-Z0-9_-]/g, "_")}.json`);
+    }
+    async prepare(input) {
+        const receipt = {
+            schemaVersion: 1,
+            state: "prepared",
+            ...input,
+        };
+        await mkdir(this.dir, { recursive: true, mode: 0o700 });
+        await writeFile(this.file(receipt.receiptId), `${JSON.stringify(receipt, null, 2)}\n`, { mode: 0o600 });
+        return receipt;
+    }
+    async get(id) {
+        try {
+            return JSON.parse(await readFile(this.file(id), "utf8"));
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        }
+    }
+    /**
+     * Atomically claim a prepared receipt for dispatch.
+     * Concurrent callers: only one gets reserved=true; others see
+     * already-dispatching / already-dispatched with the same receipt.
+     */
+    async tryReserve(id) {
+        const receipt = await this.get(id);
+        if (!receipt) {
+            return {
+                ok: false,
+                code: "NOT_FOUND",
+                message: `mutation gate receipt not found: ${id}`,
+            };
+        }
+        if (Date.parse(receipt.expiresAt) <= Date.now()) {
+            return {
+                ok: false,
+                code: "EXPIRED",
+                message: "mutation gate receipt expired",
+                receipt,
+            };
+        }
+        if (receipt.state === "dispatching") {
+            return {
+                ok: true,
+                receipt,
+                reserved: false,
+                reason: "already-dispatching",
+            };
+        }
+        if (receipt.state === "dispatched") {
+            return {
+                ok: true,
+                receipt,
+                reserved: false,
+                reason: "already-dispatched",
+            };
+        }
+        if (receipt.state !== "prepared") {
+            return {
+                ok: false,
+                code: "INVALID_STATE",
+                message: `mutation gate receipt is ${receipt.state}`,
+                receipt,
+            };
+        }
+        const next = {
+            ...receipt,
+            state: "dispatching",
+            reservedAt: new Date().toISOString(),
+        };
+        const claimed = await this.compareAndSwap(id, "prepared", next);
+        if (!claimed.ok) {
+            const current = claimed.current;
+            if (current?.state === "dispatching") {
+                return {
+                    ok: true,
+                    receipt: current,
+                    reserved: false,
+                    reason: "already-dispatching",
+                };
+            }
+            if (current?.state === "dispatched") {
+                return {
+                    ok: true,
+                    receipt: current,
+                    reserved: false,
+                    reason: "already-dispatched",
+                };
+            }
+            return {
+                ok: false,
+                code: "INVALID_STATE",
+                message: `mutation gate receipt raced into ${current?.state ?? "missing"}`,
+                receipt: current,
+            };
+        }
+        return { ok: true, receipt: next, reserved: true };
+    }
+    async markDispatched(id, operationId) {
+        const receipt = await this.get(id);
+        if (!receipt)
+            throw new Error(`receipt not found: ${id}`);
+        const next = {
+            ...receipt,
+            state: "dispatched",
+            operationId,
+            dispatchedAt: new Date().toISOString(),
+        };
+        await writeFile(this.file(id), `${JSON.stringify(next, null, 2)}\n`, {
+            mode: 0o600,
+        });
+        return next;
+    }
+    /** Best-effort unlock if dispatch failed after reserve. */
+    async releaseToPrepared(id) {
+        const receipt = await this.get(id);
+        if (!receipt || receipt.state !== "dispatching")
+            return receipt;
+        const next = {
+            ...receipt,
+            state: "prepared",
+            reservedAt: undefined,
+        };
+        await writeFile(this.file(id), `${JSON.stringify(next, null, 2)}\n`, {
+            mode: 0o600,
+        });
+        return next;
+    }
+    async compareAndSwap(id, expectedState, next) {
+        await mkdir(this.dir, { recursive: true, mode: 0o700 });
+        const target = this.file(id);
+        const lockPath = `${target}.lock`;
+        try {
+            await writeFile(lockPath, `${process.pid}\n`, { flag: "wx", mode: 0o600 });
+        }
+        catch (error) {
+            if (error.code === "EEXIST") {
+                // Brief spin for the other writer; then re-read.
+                await new Promise((r) => setTimeout(r, 25));
+                return { ok: false, current: await this.get(id) };
+            }
+            throw error;
+        }
+        try {
+            const current = await this.get(id);
+            if (!current || current.state !== expectedState) {
+                return { ok: false, current };
+            }
+            const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
+            await writeFile(tmp, `${JSON.stringify(next, null, 2)}\n`, {
+                mode: 0o600,
+            });
+            await rename(tmp, target);
+            return { ok: true };
+        }
+        finally {
+            try {
+                await writeFile(lockPath, "", { flag: "w" });
+                const { unlink } = await import("node:fs/promises");
+                await unlink(lockPath);
+            }
+            catch {
+                // lock cleanup is best-effort
+            }
+        }
+    }
+}