@nowcrew/daemon 0.6.65 → 0.6.66

package/dist/local-memory/write.js

@@ -1,448 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import { lstat, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
-import { dirname, join, relative, resolve, sep } from "node:path";
-import { z } from "zod";
-import { containsLikelySecret } from "../agent-memory/policy.js";
-import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, renderLocalMemoryIndexCard, selectLocalMemoryIndexEntries, } from "./index-budget.js";
-import { persistPendingMemoryCandidate } from "./pending.js";
-const CategorySchema = z.enum([
-    "preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons",
-]);
-const SingleLineText = z.string().trim().min(1).max(500).regex(/^[^\r\n]+$/u);
-const ChangeSchema = z.object({
-    operation: z.enum(["create", "update", "supersede"]),
-    memoryId: SingleLineText.regex(/^[^<>]+$/u).nullable(),
-    baseRevision: z.number().int().nonnegative().nullable(),
-    supersedesMemoryId: SingleLineText.regex(/^[^<>]+$/u).nullable(),
-    title: SingleLineText.max(120),
-    kind: z.enum(["procedural", "semantic", "episodic", "preference"]),
-    summary: SingleLineText,
-    triggers: z.array(SingleLineText.max(80)).min(1).max(16),
-    priority: z.enum(["high", "medium", "low"]),
-    detailCategory: CategorySchema,
-    detailBody: z.string().trim().min(1).max(12_000),
-    reviewAfter: SingleLineText.nullable(),
-}).strict();
-const StatusChangeSchema = z.object({
-    memoryId: SingleLineText,
-    expectedRevision: z.number().int().positive(),
-    expectedStatus: z.enum(["candidate", "active", "pinned", "stale", "superseded", "archived"]),
-    targetStatus: z.enum(["candidate", "active", "pinned", "stale", "archived"]),
-    reason: z.enum(["user_explicit", "manual_review"]),
-}).strict();
-const ResultSchema = z.object({
-    schemaVersion: z.literal(1),
-    purpose: z.literal("memory_prune"),
-    baseCatalogRevision: z.number().int().nonnegative(),
-    outcome: z.enum(["no_change", "proposed", "conflict", "failed"]),
-    changes: z.array(ChangeSchema).max(50),
-    statusChanges: z.array(StatusChangeSchema).max(50),
-}).strict();
-const GENERATED_INDEX_PATTERN = /<!--\s*NOWWORK:MEMORY_INDEX:BEGIN\s+schema=1\s*-->[\s\S]*?<!--\s*NOWWORK:MEMORY_INDEX:END\s*-->/u;
-const INDEX_HEADING = /^##\s+Knowledge Index\s*$/mu;
-const NEXT_SECTION = /^##\s+(?!#)/mu;
-const CARD_HEADING = /^###\s+(.+?)\s*$/gmu;
-const FIELD_LINE = /^-\s+([a-z][a-z_]*)\s*:\s*(.*?)\s*$/iu;
-const CONTROL_CHARACTER_PATTERN = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u;
-const RESERVED_MEMORY_MARKER = /NOWWORK:(?:MEMORY_ENTRY|MEMORY_INDEX):/iu;
-function codePointLength(value) {
-    return Array.from(value).length;
-}
-function detailPath(category) {
-    return `notes/${category}.md`;
-}
-function parseStatus(value) {
-    return value === "candidate" || value === "active" || value === "pinned"
-        || value === "stale" || value === "superseded" || value === "archived"
-        ? value
-        : "active";
-}
-function parseCard(titleLine, body) {
-    const fields = {};
-    for (const line of body.split(/\r?\n/u)) {
-        const match = FIELD_LINE.exec(line);
-        if (match?.[1] !== undefined && match[2] !== undefined)
-            fields[match[1].toLowerCase()] = match[2];
-    }
-    const title = titleLine.trim().replace(/^\[|\]$/gu, "").trim();
-    const file = fields.file?.trim();
-    if (!title || !file)
-        return null;
-    const priority = fields.priority === "high" || fields.priority === "low" ? fields.priority : "medium";
-    const revision = Number(fields.revision);
-    return {
-        id: fields.id?.trim() || `legacy:${file}:${title}`,
-        title,
-        file,
-        type: fields.type === "procedural" || fields.type === "episodic" || fields.type === "preference"
-            ? fields.type
-            : "semantic",
-        status: parseStatus(fields.status),
-        summary: fields.summary?.trim() ?? "",
-        triggers: [...new Set((fields.triggers ?? "").split(/[,，、]/u).map((value) => value.trim()).filter(Boolean))],
-        priority,
-        updated: fields.updated?.trim() ?? "",
-        anchor: fields.anchor?.trim() || null,
-        revision: Number.isInteger(revision) && revision > 0 ? revision : 1,
-        reviewAfter: fields.review_after?.trim() || null,
-    };
-}
-function indexSection(memory) {
-    const heading = INDEX_HEADING.exec(memory);
-    if (heading === null || heading.index === undefined)
-        return "";
-    const start = heading.index + heading[0].length;
-    const rest = memory.slice(start);
-    const next = NEXT_SECTION.exec(rest);
-    return next?.index === undefined ? rest : rest.slice(0, next.index);
-}
-function parseCards(section) {
-    const withoutComments = section.replace(/<!--[\s\S]*?-->/gu, "");
-    const headings = [...withoutComments.matchAll(CARD_HEADING)];
-    return headings.flatMap((heading, index) => {
-        if (heading.index === undefined || heading[1] === undefined)
-            return [];
-        const bodyStart = heading.index + heading[0].length;
-        const bodyEnd = headings[index + 1]?.index ?? withoutComments.length;
-        const card = parseCard(heading[1], withoutComments.slice(bodyStart, bodyEnd));
-        return card === null ? [] : [card];
-    });
-}
-export function parseLocalMemoryIndex(memory) {
-    const section = indexSection(memory);
-    const generated = GENERATED_INDEX_PATTERN.exec(section)?.[0];
-    return parseCards(generated ?? section);
-}
-function parseUnmarkedMemoryIndex(memory) {
-    const section = indexSection(memory).replace(GENERATED_INDEX_PATTERN, "");
-    return parseCards(section);
-}
-function renderGeneratedIndex(entries) {
-    const cards = entries
-        .filter((entry) => entry.status === "pinned" || entry.status === "active")
-        .map(renderLocalMemoryIndexCard)
-        .join("\n");
-    return `<!-- NOWWORK:MEMORY_INDEX:BEGIN schema=1 -->\n${cards}<!-- NOWWORK:MEMORY_INDEX:END -->`;
-}
-function replaceGeneratedIndex(memory, entries) {
-    const generated = renderGeneratedIndex(entries);
-    if (GENERATED_INDEX_PATTERN.test(memory))
-        return memory.replace(GENERATED_INDEX_PATTERN, generated);
-    const heading = INDEX_HEADING.exec(memory);
-    if (heading?.index !== undefined) {
-        const afterHeading = heading.index + heading[0].length;
-        return `${memory.slice(0, afterHeading)}\n${generated}${memory.slice(afterHeading)}`;
-    }
-    return `${memory.trimEnd()}\n\n## Knowledge Index\n${generated}\n`;
-}
-function noteSection(id, revision, title, body) {
-    return `<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${id} revision=${revision} -->\n`
-        + `## ${title}\n\n${body.trim()}\n`
-        + `<!-- NOWWORK:MEMORY_ENTRY:END id=${id} -->\n`;
-}
-function notePattern(id) {
-    const escaped = id.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-    return new RegExp(`<!--\\s*NOWWORK:MEMORY_ENTRY:BEGIN\\s+id=${escaped}[^>]*-->[\\s\\S]*?<!--\\s*NOWWORK:MEMORY_ENTRY:END\\s+id=${escaped}\\s*-->\\s*`, "u");
-}
-function replaceNote(content, id, replacement) {
-    const pattern = notePattern(id);
-    return pattern.test(content) ? content.replace(pattern, replacement) : null;
-}
-function containsReservedText(change) {
-    return RESERVED_MEMORY_MARKER.test([change.title, change.summary, ...change.triggers, change.detailBody].join("\n"));
-}
-function validateCandidate(result) {
-    if (result.outcome === "no_change" && (result.changes.length > 0 || result.statusChanges.length > 0)) {
-        throw new Error("local_memory_no_change_has_operations");
-    }
-    for (const change of result.changes) {
-        const text = [change.title, change.summary, ...change.triggers, change.detailBody].join("\n");
-        if (containsLikelySecret(text))
-            throw new Error("local_memory_secret_candidate");
-        if (CONTROL_CHARACTER_PATTERN.test(text))
-            throw new Error("local_memory_control_character");
-        if (containsReservedText(change))
-            throw new Error("local_memory_reserved_marker");
-        if (change.operation === "create"
-            && (change.memoryId !== null || change.baseRevision !== null || change.supersedesMemoryId !== null)) {
-            throw new Error("local_memory_create_revision_invalid");
-        }
-        if (change.operation === "update"
-            && (change.memoryId === null || change.baseRevision === null || change.supersedesMemoryId !== null)) {
-            throw new Error("local_memory_update_revision_missing");
-        }
-        if (change.operation === "supersede"
-            && (change.memoryId !== null || change.baseRevision === null || change.supersedesMemoryId === null)) {
-            throw new Error("local_memory_supersede_revision_missing");
-        }
-    }
-}
-export function parseLocalMemoryResult(raw) {
-    let value;
-    try {
-        value = JSON.parse(raw);
-    }
-    catch {
-        throw new Error("local_memory_result_json_invalid");
-    }
-    const parsed = ResultSchema.safeParse(value);
-    if (!parsed.success)
-        throw new Error(`local_memory_result_invalid:${parsed.error.issues[0]?.path.join(".") ?? "unknown"}`);
-    validateCandidate(parsed.data);
-    return parsed.data;
-}
-function entryFromChange(change, id, revision, status) {
-    return {
-        id,
-        title: change.title,
-        file: detailPath(change.detailCategory),
-        type: change.kind,
-        status,
-        summary: change.summary,
-        triggers: [...new Set(change.triggers)],
-        priority: change.priority,
-        updated: new Date().toISOString().slice(0, 10),
-        anchor: id,
-        revision,
-        reviewAfter: change.reviewAfter,
-    };
-}
-function matchesCreateCandidate(entry, change) {
-    const triggers = [...new Set(change.triggers)];
-    return entry.title === change.title
-        && entry.file === detailPath(change.detailCategory)
-        && entry.type === change.kind
-        && entry.summary === change.summary
-        && entry.priority === change.priority
-        && entry.reviewAfter === change.reviewAfter
-        && entry.triggers.length === triggers.length
-        && entry.triggers.every((trigger, index) => trigger === triggers[index]);
-}
-function stableId(executionId, index, change) {
-    const input = [executionId, String(index), change.operation, change.title, change.summary, change.detailBody].join("\0");
-    return `mem_${createHash("sha256").update(input, "utf8").digest("hex").slice(0, 12)}`;
-}
-function normalize(value) {
-    return value.normalize("NFKC").toLocaleLowerCase().replace(/\s+/gu, " ").trim();
-}
-function activeOrPinnedIds(entries) {
-    return new Set(entries.filter((entry) => entry.status === "active" || entry.status === "pinned").map((entry) => entry.id));
-}
-function emptyResult() {
-    return { createdIds: [], updatedIds: [], statusChangedIds: [], deferredIds: [], pendingIds: [] };
-}
-function isWithin(root, candidate) {
-    const path = relative(root, candidate);
-    return path === "" || (path !== ".." && !path.startsWith(`..${sep}`));
-}
-async function assertWritablePaths(agentDir, memoryPath) {
-    const agentRoot = await realpath(agentDir);
-    const notesPath = join(agentDir, "notes");
-    const notesRoot = await realpath(notesPath);
-    if (notesRoot !== resolve(agentRoot, "notes") || !isWithin(agentRoot, notesRoot))
-        throw new Error("local_memory_notes_path_invalid");
-    const memoryStat = await lstat(memoryPath);
-    if (!memoryStat.isFile() || memoryStat.isSymbolicLink())
-        throw new Error("local_memory_memory_path_invalid");
-}
-async function readNote(path) {
-    try {
-        const stat = await lstat(path);
-        if (!stat.isFile() || stat.isSymbolicLink())
-            throw new Error("local_memory_note_path_invalid");
-        return await readFile(path, "utf8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return "";
-        throw error;
-    }
-}
-async function atomicWrite(path, content) {
-    const temporary = `${path}.tmp-${randomUUID()}`;
-    try {
-        await writeFile(temporary, content, { encoding: "utf8", mode: 0o600 });
-        await rename(temporary, path);
-    }
-    catch (error) {
-        await rm(temporary, { force: true }).catch(() => undefined);
-        throw error;
-    }
-}
-function projectIndex(memory, entries, protectedIds) {
-    const empty = replaceGeneratedIndex(memory, []);
-    if (codePointLength(empty) > LOCAL_MEMORY_TOTAL_CODE_POINT_CAP)
-        throw new Error("local_memory_memory_over_budget");
-    const emptyIndex = renderGeneratedIndex([]);
-    const remainingTotal = LOCAL_MEMORY_TOTAL_CODE_POINT_CAP - codePointLength(empty);
-    const selection = selectLocalMemoryIndexEntries(entries, {
-        indexCodePointCap: Math.min(Math.max(0, LOCAL_MEMORY_INDEX_CODE_POINT_CAP - codePointLength(emptyIndex)), remainingTotal),
-        entryCap: LOCAL_MEMORY_INDEX_ENTRY_CAP,
-    }, { protectedIds });
-    return {
-        memory: replaceGeneratedIndex(memory, selection.entries),
-        omittedIds: selection.omittedIds,
-        reason: selection.reason,
-    };
-}
-const applyTails = new Map();
-async function withApplyLease(agentDir, operation) {
-    const key = resolve(agentDir);
-    const previous = applyTails.get(key) ?? Promise.resolve();
-    let release;
-    const current = new Promise((resolveCurrent) => { release = resolveCurrent; });
-    const tail = previous.then(() => current);
-    applyTails.set(key, tail);
-    await previous;
-    try {
-        return await operation();
-    }
-    finally {
-        release();
-        void tail.then(() => {
-            if (applyTails.get(key) === tail)
-                applyTails.delete(key);
-        });
-    }
-}
-export async function applyLocalMemoryResult(input) {
-    validateCandidate(input.result);
-    if (input.result.outcome !== "proposed")
-        return emptyResult();
-    const memoryPath = join(input.agentDir, "MEMORY.md");
-    await assertWritablePaths(input.agentDir, memoryPath);
-    return withApplyLease(input.agentDir, async () => {
-        const memory = await readFile(memoryPath, "utf8");
-        if (parseUnmarkedMemoryIndex(memory).length > 0)
-            throw new Error("local_memory_legacy_index_requires_migration");
-        let entries = [...parseLocalMemoryIndex(memory)];
-        for (const entry of entries) {
-            if (!isWithin(resolve(input.agentDir, "notes"), resolve(input.agentDir, entry.file))) {
-                throw new Error("local_memory_note_path_invalid");
-            }
-        }
-        const contentIds = new Set(input.result.changes.flatMap((change) => [
-            ...(change.operation === "update" && change.memoryId !== null ? [change.memoryId] : []),
-            ...(change.supersedesMemoryId === null ? [] : [change.supersedesMemoryId]),
-        ]));
-        for (const statusChange of input.result.statusChanges) {
-            if (contentIds.has(statusChange.memoryId))
-                throw new Error("local_memory_status_conflict");
-            const current = entries.find((entry) => entry.id === statusChange.memoryId);
-            if (current === undefined || current.revision !== statusChange.expectedRevision || current.status !== statusChange.expectedStatus) {
-                throw new Error("local_memory_status_conflict");
-            }
-            entries = entries.map((entry) => entry.id === statusChange.memoryId
-                ? { ...entry, status: statusChange.targetStatus, revision: entry.revision + 1 }
-                : entry);
-        }
-        const createdIds = [];
-        const updatedIds = [];
-        const statusChangedIds = input.result.statusChanges.map((change) => change.memoryId);
-        const deferredIds = [];
-        const pendingCandidates = [];
-        const noteUpdates = new Map();
-        const randomId = input.randomId ?? randomUUID;
-        const executionId = input.executionId ?? "unknown";
-        const defer = (change, index) => {
-            const candidateId = input.executionId === undefined ? `mem_${randomId()}` : stableId(executionId, index, change);
-            const pendingId = `pending-${candidateId.slice("mem_".length)}`;
-            pendingCandidates.push({
-                schemaVersion: 1,
-                pendingId,
-                createdAt: new Date().toISOString(),
-                reason: "index_over_budget",
-                source: { executionId, pruneTraceId: input.pruneTraceId ?? null },
-                candidate: change,
-            });
-            deferredIds.push(pendingId);
-        };
-        for (const [index, change] of input.result.changes.entries()) {
-            const id = change.operation === "update"
-                ? change.memoryId
-                : input.executionId === undefined ? `mem_${randomId()}` : stableId(executionId, index, change);
-            const existingCreate = change.operation === "create" ? entries.find((entry) => entry.id === id) : undefined;
-            const current = change.operation === "update" ? entries.find((entry) => entry.id === id) : undefined;
-            if (change.operation === "update") {
-                if (current === undefined)
-                    throw new Error("local_memory_revision_conflict_missing_id");
-                if (change.baseRevision !== current.revision)
-                    throw new Error("local_memory_revision_conflict");
-            }
-            const superseded = change.operation === "supersede"
-                ? entries.find((entry) => entry.id === change.supersedesMemoryId)
-                : undefined;
-            if (change.operation === "supersede") {
-                if (superseded === undefined)
-                    throw new Error("local_memory_supersede_missing_id");
-                if (change.baseRevision !== superseded.revision)
-                    throw new Error("local_memory_supersede_revision_conflict");
-            }
-            if (change.operation === "create") {
-                if (existingCreate !== undefined && !matchesCreateCandidate(existingCreate, change)) {
-                    throw new Error("local_memory_duplicate_candidate");
-                }
-                if (existingCreate === undefined && entries.some((entry) => normalize(entry.title) === normalize(change.title)
-                    || normalize(entry.summary) === normalize(change.summary))) {
-                    throw new Error("local_memory_duplicate_candidate");
-                }
-            }
-            const revision = existingCreate?.revision ?? (current === undefined ? 1 : current.revision + 1);
-            const entry = existingCreate ?? entryFromChange(change, id, revision, current?.status ?? "active");
-            const candidateEntries = existingCreate !== undefined
-                ? entries
-                : change.supersedesMemoryId === null
-                    ? current === undefined ? [...entries, entry] : entries.map((item) => item.id === id ? entry : item)
-                    : [
-                        ...entries.map((item) => item.id === change.supersedesMemoryId
-                            ? { ...item, status: "superseded", revision: item.revision + 1 }
-                            : item),
-                        entry,
-                    ];
-            const protectedIds = new Set(activeOrPinnedIds(entries));
-            if (change.supersedesMemoryId !== null)
-                protectedIds.delete(change.supersedesMemoryId);
-            const projection = projectIndex(memory, candidateEntries, protectedIds);
-            const omitted = (entry.status === "active" || entry.status === "pinned") && projection.omittedIds.includes(id);
-            if (change.operation === "update" && omitted)
-                throw new Error(projection.reason ?? "local_memory_index_over_budget");
-            if ((change.operation === "create" || change.operation === "supersede") && omitted) {
-                defer(change, index);
-                continue;
-            }
-            const notePath = resolve(input.agentDir, entry.file);
-            if (!isWithin(resolve(input.agentDir, "notes"), notePath))
-                throw new Error("local_memory_note_path_invalid");
-            const previous = noteUpdates.get(notePath) ?? await readNote(notePath);
-            const replacement = noteSection(id, revision, change.title, change.detailBody);
-            const existingSection = replaceNote(previous, id, replacement);
-            const next = existingSection ?? (current === undefined
-                ? `${previous.trimEnd()}${previous.trimEnd() ? "\n\n" : ""}${replacement}`
-                : null);
-            if (next === null)
-                throw new Error("local_memory_note_anchor_missing");
-            noteUpdates.set(notePath, next);
-            entries = candidateEntries;
-            if (change.operation === "update")
-                updatedIds.push(id);
-            else if (existingCreate === undefined)
-                createdIds.push(id);
-        }
-        const finalProjection = projectIndex(memory, entries, activeOrPinnedIds(entries));
-        if (finalProjection.reason !== null)
-            throw new Error(finalProjection.reason);
-        for (const candidate of pendingCandidates)
-            await persistPendingMemoryCandidate({ agentDir: input.agentDir, candidate });
-        for (const [path, content] of noteUpdates)
-            await atomicWrite(path, content);
-        if (noteUpdates.size > 0 || statusChangedIds.length > 0)
-            await atomicWrite(memoryPath, finalProjection.memory);
-        return {
-            createdIds,
-            updatedIds,
-            statusChangedIds,
-            deferredIds,
-            pendingIds: deferredIds,
-        };
-    });
-}

package/dist/runtimes/codex-command-safety.js

@@ -1,75 +0,0 @@
-/**
- * Codex app-server 重试门控用的「只读 crew 命令」判定(spec Part 1,R3-1/R4-1)。
- *
- * 白名单 + 封闭文法,不是黑名单:任何解析不确定都返回 false。只回答"这是不是白名单里某条
- * crew 只读命令的一次干净调用",不做"读/写"语义判断。任何非 crew 命令(sed/rg/git/python…)
- * 一律 false——白名单之外的一切都视为不可安全重试。零 IO,可独立单测。
- */
-/** 封闭列表,由 cli/src/run.ts 命令面反推;新增 CLI 只读命令时同步维护。漏加只会更保守。 */
-export const READ_ONLY_CREW_COMMANDS = new Set([
-    "whoami",
-    "server info",
-    "message read",
-    "message check",
-    "thread read",
-    "task list",
-    "schedule list",
-    "schedule runs",
-    "reminder list",
-    "reminder log",
-    "resolve",
-    "channel members",
-    "integration env",
-    "integration list",
-]);
-const SINGLE_VERB = new Set(["whoami", "resolve"]);
-// 一层 shell 包装:bash/sh/zsh -c / -lc / -cl,后跟被单引号或双引号整体包裹的正文。
-const WRAPPER = /^(?:\/usr\/bin\/|\/bin\/)?(?:bash|sh|zsh)\s+-(?:l?c|cl)\s+(.+)$/su;
-// 整串禁字符:出现任一即拒绝(含单个 &、引号、$、括号、换行、制表、反斜杠)。
-const FORBIDDEN = /[&;|<>$`(){}\\'"\n\r\t]/u;
-const OPTION_TOKEN = /^--?[A-Za-z][A-Za-z0-9-]*(?:=[A-Za-z0-9._:/@#%+-]+)?$/u;
-const VALUE_TOKEN = /^[A-Za-z0-9._:/@#%+][A-Za-z0-9._:/@#%+-]+$/u;
-function unwrap(command) {
-    const match = WRAPPER.exec(command);
-    if (match === null)
-        return command;
-    const quoted = match[1] ?? "";
-    const quote = quoted[0];
-    if (quote !== "'" && quote !== "\"")
-        return null;
-    if (quoted.length < 2 || quoted[quoted.length - 1] !== quote)
-        return null;
-    const body = quoted.slice(1, -1);
-    if (body.includes(quote))
-        return null;
-    if (quote === "\"" && /[$\\]/u.test(body))
-        return null;
-    return body;
-}
-export function isReadOnlyCrewCommand(command) {
-    const body = unwrap(command);
-    if (body === null)
-        return false;
-    if (FORBIDDEN.test(body))
-        return false;
-    const trimmed = body.trim();
-    if (trimmed === "" || /\s{2,}/u.test(trimmed))
-        return false;
-    const tokens = trimmed.split(" ");
-    if (tokens[0] !== "crew")
-        return false;
-    const verb = tokens[1];
-    if (verb === undefined)
-        return false;
-    let consumed;
-    if (SINGLE_VERB.has(verb)) {
-        consumed = 2;
-    }
-    else {
-        const pair = `${verb} ${tokens[2] ?? ""}`;
-        if (!READ_ONLY_CREW_COMMANDS.has(pair))
-            return false;
-        consumed = 3;
-    }
-    return tokens.slice(consumed).every((token) => OPTION_TOKEN.test(token) || VALUE_TOKEN.test(token));
-}

package/dist/runtimes/codex-turn-retry.js

@@ -1,69 +0,0 @@
-/**
- * Codex app-server turn 级重试决策(spec Part 1)。
- *
- * attempt 只上报两个正交事实:retryReason(为什么值得重试)与 unsafeToRetry(本 turn 是否已有
- * 白名单之外的工具活动)。外层循环通过 decideTurnRetry 单一出口判断,所有原因共用一个预算。
- * 2026-08-10 事故根因:模型自己调 collaboration.interrupt_agent,Codex 把父 turn 也置为
- * interrupted;旧代码直接 exit 130。同时旧的网关过载重试是无条件的,会重放 crew message send。
- */
-import { isReadOnlyCrewCommand } from "./codex-command-safety.js";
-/**
- * Codex app-server v2 `codex app-server generate-json-schema` ThreadItem 枚举的全部 18 种类型,
- * 逐一裁定安全性(2026-08-28 最终评审 F1:实测真实 app-server 0.150.1 发现 userMessage 缺失导致
- * 所有 turn 被判不安全,回归影响过载重试与 interrupted 重试两条路径)。新增协议类型时,必须在此
- * 表格里显式落座,不允许静默归类。
- *
- * safe(协议/叙述类,无副作用,共 9 种):
- *   - userMessage        Codex 对我们自己发送的 prompt 的回显,每个 turn 必有
- *   - hookPrompt          hook 触发的系统提示回显
- *   - agentMessage        模型最终回复文本
- *   - reasoning           模型推理过程(不透出给下游)
- *   - plan                模型计划更新
- *   - contextCompaction   上下文压缩通知
- *   - sleep               模型主动等待
- *   - enteredReviewMode   进入 review 模式通知
- *   - exitedReviewMode    退出 review 模式通知
- * conditional(1 种,视具体内容而定):
- *   - commandExecution    仅当 isReadOnlyCrewCommand(command) 为 true 时安全
- * unsafe(有副作用或无法判断,共 8 种 + 未知类型):
- *   - fileChange          写文件
- *   - mcpToolCall          调用外部 MCP 工具
- *   - dynamicToolCall      调用动态工具
- *   - collabAgentToolCall  协作工具(spawnAgent/interrupt_agent 等)
- *   - subAgentActivity     子 agent 活动
- *   - webSearch            联网搜索
- *   - imageView            查看图片
- *   - imageGeneration      生成图片
- *   - (任何未知/缺失 type)  一律视为不安全
- */
-const NARRATIVE_ITEM_TYPES = new Set([
-    "userMessage",
-    "hookPrompt",
-    "agentMessage",
-    "reasoning",
-    "plan",
-    "contextCompaction",
-    "sleep",
-    "enteredReviewMode",
-    "exitedReviewMode",
-]);
-/** 白名单判定:只有叙述类 item 和白名单内的 crew 只读命令是安全的;其它一切(含未知类型)不安全。 */
-export function itemMakesTurnUnsafe(item) {
-    if (item?.type === undefined)
-        return true;
-    if (NARRATIVE_ITEM_TYPES.has(item.type))
-        return false;
-    if (item.type === "commandExecution") {
-        return typeof item.command !== "string" || !isReadOnlyCrewCommand(item.command);
-    }
-    return true;
-}
-export function decideTurnRetry(result, turnRetries, maxRetries) {
-    if (result.retryReason === undefined)
-        return { kind: "return" };
-    if (result.unsafeToRetry)
-        return { kind: "skipped", reason: result.retryReason };
-    if (turnRetries < maxRetries)
-        return { kind: "retry", reason: result.retryReason };
-    return { kind: "exhausted", reason: result.retryReason };
-}