feishu-codex-console 1.0.0-beta.6

package/dist/team-card.js

@@ -0,0 +1,275 @@
+export function renderTeamDashboardCard(snapshot) {
+    return {
+        schema: "2.0",
+        config: {
+            update_multi: true,
+            width_mode: "default",
+            enable_forward: false,
+            summary: {
+                content: `Codex 团队工作台 · 活跃 ${snapshot.activeTasks} · 成功率 ${successRateLabel(snapshot.successRate)}`,
+            },
+        },
+        header: {
+            title: { tag: "plain_text", content: "Codex 团队工作台" },
+            subtitle: { tag: "plain_text", content: snapshot.scopeLabel },
+            template: snapshot.activeTasks > 0 ? "blue" : "turquoise",
+            icon: { tag: "standard_icon", token: "group_colorful" },
+            text_tag_list: [
+                {
+                    tag: "text_tag",
+                    text: { tag: "plain_text", content: snapshot.periodLabel },
+                    color: "neutral",
+                },
+                {
+                    tag: "text_tag",
+                    text: {
+                        tag: "plain_text",
+                        content: snapshot.canAdminister ? "团队视图" : "个人视图",
+                    },
+                    color: snapshot.canAdminister ? "violet" : "blue",
+                },
+            ],
+        },
+        body: {
+            direction: "vertical",
+            padding: "12px 12px 18px 12px",
+            vertical_spacing: "12px",
+            elements: [
+                ...(snapshot.feedback ? [feedbackPanel(snapshot.feedback)] : []),
+                metricRow(snapshot),
+                usagePanel(snapshot),
+                sectionTitle("team_members_title", "成员状态", `${snapshot.members.length} 位可见成员`),
+                ...(snapshot.members.length > 0
+                    ? snapshot.members.slice(0, 8).map(memberPanel)
+                    : [emptyPanel("team_members_empty", "暂无成员任务数据")]),
+                sectionTitle("team_projects_title", "项目负载", "按最近保留的任务记录统计"),
+                ...(snapshot.projects.length > 0
+                    ? snapshot.projects.slice(0, 6).map(projectPanel)
+                    : [emptyPanel("team_projects_empty", "暂无项目任务数据")]),
+                actionGrid(),
+                {
+                    tag: "markdown",
+                    element_id: "team_privacy_note",
+                    text_size: "notation",
+                    text_align: "center",
+                    content: "<font color='grey'>团队面板不展示提示词、结果正文或 open_id；管理操作均写入本地审计。</font>",
+                },
+            ],
+        },
+    };
+}
+function metricRow(snapshot) {
+    return {
+        tag: "column_set",
+        element_id: "team_metrics",
+        flex_mode: "none",
+        horizontal_spacing: "8px",
+        columns: [
+            metricColumn("活跃任务", String(snapshot.activeTasks), "blue"),
+            metricColumn("排队任务", String(snapshot.queuedTasks), "grey"),
+            metricColumn("成功率", successRateLabel(snapshot.successRate), "green"),
+        ],
+    };
+}
+function metricColumn(label, value, color) {
+    return {
+        tag: "column",
+        width: "weighted",
+        weight: 1,
+        background_style: `${color}-50`,
+        padding: "10px 6px 10px 6px",
+        vertical_spacing: "2px",
+        elements: [
+            {
+                tag: "markdown",
+                text_align: "center",
+                text_size: "notation",
+                content: `<font color='grey'>${safe(label)}</font>`,
+            },
+            {
+                tag: "markdown",
+                text_align: "center",
+                content: `**${safe(value)}**`,
+            },
+        ],
+    };
+}
+function usagePanel(snapshot) {
+    return {
+        tag: "column_set",
+        element_id: "team_usage",
+        flex_mode: "none",
+        columns: [
+            {
+                tag: "column",
+                width: "weighted",
+                weight: 1,
+                background_style: "grey-50",
+                padding: "10px 12px 10px 12px",
+                elements: [
+                    {
+                        tag: "markdown",
+                        element_id: "team_usage_text",
+                        content: `**资源概览**  已完成 ${formatNumber(snapshot.completedTasks)} 个任务\n` +
+                            `<font color='grey'>输入 / 输出 tokens</font>  ${formatNumber(snapshot.inputTokens)} / ${formatNumber(snapshot.outputTokens)}`,
+                    },
+                ],
+            },
+        ],
+    };
+}
+function memberPanel(member, index) {
+    const completed = member.succeeded + member.failed;
+    const rate = completed > 0 ? member.succeeded / completed : undefined;
+    return {
+        tag: "column_set",
+        element_id: `team_member_${index}`,
+        flex_mode: "none",
+        columns: [
+            {
+                tag: "column",
+                width: "weighted",
+                weight: 1,
+                background_style: member.active > 0 ? "blue-50" : "grey-50",
+                padding: "10px 12px 10px 12px",
+                elements: [
+                    {
+                        tag: "markdown",
+                        element_id: `team_member_text_${index}`,
+                        content: `**${safe(member.label)}**  ${roleTag(member.role)}${member.active > 0 ? "  <text_tag color='blue'>执行中</text_tag>" : ""}\n` +
+                            `<font color='grey'>发起 ${member.tasks} · 控制 ${member.controlled} · 成功率 ${successRateLabel(rate)} · tokens ${formatCompact(member.inputTokens + member.outputTokens)}</font>`,
+                    },
+                ],
+            },
+        ],
+    };
+}
+function projectPanel(project, index) {
+    return {
+        tag: "column_set",
+        element_id: `team_project_${index}`,
+        flex_mode: "none",
+        columns: [
+            {
+                tag: "column",
+                width: "weighted",
+                weight: 1,
+                background_style: project.active > 0 ? "blue-50" : "grey-50",
+                padding: "10px 12px 10px 12px",
+                elements: [
+                    {
+                        tag: "markdown",
+                        element_id: `team_project_text_${index}`,
+                        content: `**${safe(project.label)}**${project.active > 0 ? `  <text_tag color='blue'>活跃 ${project.active}</text_tag>` : ""}\n` +
+                            `<font color='grey'>${project.tasks} 个任务 · ${project.members} 位成员</font>`,
+                    },
+                ],
+            },
+        ],
+    };
+}
+function sectionTitle(id, title, detail) {
+    return {
+        tag: "markdown",
+        element_id: id,
+        content: `**${safe(title)}**\n<font color='grey'>${safe(detail)}</font>`,
+    };
+}
+function emptyPanel(id, text) {
+    return {
+        tag: "column_set",
+        element_id: id,
+        flex_mode: "none",
+        columns: [
+            {
+                tag: "column",
+                width: "weighted",
+                weight: 1,
+                background_style: "grey-50",
+                padding: "10px 12px 10px 12px",
+                elements: [{ tag: "markdown", content: `<font color='grey'>${safe(text)}</font>` }],
+            },
+        ],
+    };
+}
+function feedbackPanel(feedback) {
+    return {
+        tag: "column_set",
+        element_id: "team_feedback",
+        flex_mode: "none",
+        columns: [
+            {
+                tag: "column",
+                width: "weighted",
+                weight: 1,
+                background_style: "green-50",
+                padding: "10px 12px 10px 12px",
+                elements: [
+                    {
+                        tag: "markdown",
+                        content: `<font color='green'>${safe(feedback)}</font>`,
+                    },
+                ],
+            },
+        ],
+    };
+}
+function actionGrid() {
+    const actions = [
+        button("任务中心", "team_tasks", "primary"),
+        button("运行手册", "team_runbooks", "default"),
+        button("项目工作台", "team_projects", "default"),
+        button("刷新", "team_refresh", "default"),
+    ];
+    return {
+        tag: "column_set",
+        element_id: "team_actions",
+        flex_mode: "none",
+        horizontal_spacing: "8px",
+        columns: actions.map((action) => ({
+            tag: "column",
+            width: "weighted",
+            weight: 1,
+            elements: [action],
+        })),
+    };
+}
+function button(text, action, type) {
+    return {
+        tag: "button",
+        element_id: action,
+        text: { tag: "plain_text", content: text },
+        type: type === "primary" ? "primary_filled" : "default",
+        width: "fill",
+        behaviors: [
+            {
+                type: "callback",
+                value: { bridge: "feishu-codex-v5", action },
+            },
+        ],
+    };
+}
+function roleTag(role) {
+    if (role === "admin")
+        return "<text_tag color='violet'>管理员</text_tag>";
+    if (role === "operator")
+        return "<text_tag color='blue'>操作者</text_tag>";
+    return "<text_tag color='neutral'>只读成员</text_tag>";
+}
+function successRateLabel(value) {
+    return value === undefined ? "暂无" : `${Math.round(value * 100)}%`;
+}
+function formatNumber(value) {
+    return new Intl.NumberFormat("zh-CN").format(value);
+}
+function formatCompact(value) {
+    return new Intl.NumberFormat("zh-CN", { notation: "compact", maximumFractionDigits: 1 }).format(value);
+}
+function safe(value) {
+    return value
+        .replaceAll("<", "＜")
+        .replaceAll(">", "＞")
+        .replaceAll("*", "＊")
+        .replaceAll("`", "｀")
+        .slice(0, 160);
+}

package/dist/team-directory.js

@@ -0,0 +1,54 @@
+import { createHash } from "node:crypto";
+import { canAccessProject, roleForSender, roleLabel } from "./team-policy.js";
+export function memberSelector(memberId) {
+    return createHash("sha256")
+        .update(`feishu-codex-member:${memberId}`)
+        .digest("hex")
+        .slice(0, 20);
+}
+export function memberLabel(config, memberId) {
+    const configured = config.memberLabels.get(memberId)?.trim();
+    if (configured)
+        return configured;
+    return `成员 ${memberSelector(memberId).slice(0, 6).toLocaleUpperCase()}`;
+}
+export function teamMembers(config) {
+    const ids = new Set([
+        ...config.adminSenderIds,
+        ...config.allowedSenderIds,
+        ...config.viewerSenderIds,
+    ]);
+    return [...ids]
+        .map((id) => {
+        const role = roleForSender(config, id);
+        if (!role)
+            return null;
+        return {
+            id,
+            selector: memberSelector(id),
+            label: memberLabel(config, id),
+            role,
+        };
+    })
+        .filter((member) => member !== null)
+        .sort((left, right) => {
+        const roleOrder = roleRank(left.role) - roleRank(right.role);
+        return roleOrder || left.label.localeCompare(right.label, "zh-CN");
+    });
+}
+export function operatingTeamMembers(config, project) {
+    return teamMembers(config).filter((member) => member.role !== "viewer" && (!project || canAccessProject(config, member.id, project)));
+}
+export function resolveMemberSelector(config, selector) {
+    return teamMembers(config).find((member) => member.selector === selector);
+}
+export function teamMemberOptionLabel(member) {
+    return `${member.label} · ${roleLabel(member.role)}`;
+}
+function roleRank(role) {
+    if (role === "admin")
+        return 0;
+    if (role === "operator")
+        return 1;
+    return 2;
+}

package/dist/team-policy.js

@@ -0,0 +1,93 @@
+import { workspaceSessionForEvent } from "./workspace-session.js";
+export function roleForSender(config, senderId) {
+    if (config.adminSenderIds?.has(senderId))
+        return "admin";
+    if (config.allowedSenderIds.has(senderId))
+        return "operator";
+    if (config.viewerSenderIds?.has(senderId))
+        return "viewer";
+    return null;
+}
+export function canOperate(config, senderId) {
+    const role = roleForSender(config, senderId);
+    return role === "admin" || role === "operator";
+}
+export function canAdminister(config, senderId) {
+    return roleForSender(config, senderId) === "admin";
+}
+export function canControlOwnedResource(config, senderId, ownerId) {
+    return canOperate(config, senderId) && (senderId === ownerId || canAdminister(config, senderId));
+}
+export function canViewOwnedResource(config, senderId, ownerId) {
+    return roleForSender(config, senderId) !== null &&
+        (senderId === ownerId || canAdminister(config, senderId));
+}
+export function canControlTask(config, senderId, task) {
+    if (!canOperate(config, senderId))
+        return false;
+    return senderId === (task.controllerId || task.ownerId) || canAdminister(config, senderId);
+}
+export function canViewTask(config, senderId, task) {
+    if (!roleForSender(config, senderId))
+        return false;
+    return (senderId === task.ownerId ||
+        senderId === (task.controllerId || task.ownerId) ||
+        canAdminister(config, senderId));
+}
+export function canTakeOverTask(config, senderId, task) {
+    return canOperate(config, senderId) &&
+        (senderId === task.ownerId || canAdminister(config, senderId)) &&
+        senderId !== (task.controllerId || task.ownerId);
+}
+export function conversationKeyForEvent(event, config) {
+    return workspaceSessionForEvent(event, config).conversationKey;
+}
+export function conversationKeyForCard(chatId, operatorId, chatType, config) {
+    if (chatType === "group" && config.groupSessionScope === "member") {
+        return `${chatId}::${operatorId}`;
+    }
+    return chatId;
+}
+export function canAccessProject(config, senderId, project) {
+    if (!roleForSender(config, senderId))
+        return false;
+    if (canAdminister(config, senderId) || config.projectAcl.size === 0)
+        return true;
+    for (const [selector, actors] of config.projectAcl) {
+        const normalized = selector.toLocaleLowerCase();
+        const matches = selector === "*" ||
+            selector === project.path ||
+            selector === project.name ||
+            selector === project.displayPath ||
+            normalized === project.name.toLocaleLowerCase() ||
+            normalized === project.displayPath.toLocaleLowerCase();
+        if (!matches)
+            continue;
+        if (actors?.has("*") || actors?.has(senderId))
+            return true;
+    }
+    return false;
+}
+export function visibleProjects(config, senderId, projects) {
+    return projects.filter((project) => canAccessProject(config, senderId, project));
+}
+const SANDBOX_RANK = {
+    "read-only": 0,
+    "workspace-write": 1,
+    "danger-full-access": 2,
+};
+export function selectableSandboxModes(maximum) {
+    return ["read-only", "workspace-write", "danger-full-access"].filter((mode) => SANDBOX_RANK[mode] <= SANDBOX_RANK[maximum]);
+}
+export function isSandboxModeAllowed(mode, maximum) {
+    return SANDBOX_RANK[mode] <= SANDBOX_RANK[maximum];
+}
+export function roleLabel(role) {
+    if (role === "admin")
+        return "管理员";
+    if (role === "operator")
+        return "操作者";
+    if (role === "viewer")
+        return "只读成员";
+    return "未授权";
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/version.js

@@ -0,0 +1,9 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+export const PACKAGE_ROOT = path.dirname(fileURLToPath(new URL("../package.json", import.meta.url)));
+const manifest = JSON.parse(readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf8"));
+export const PACKAGE_NAME = manifest.name;
+export const PACKAGE_VERSION = manifest.version;
+export const CODEX_PACKAGE_VERSION = manifest.dependencies?.["@openai/codex"] ?? "unknown";
+export const LARK_CLI_PACKAGE_VERSION = manifest.dependencies?.["@larksuite/cli"] ?? "unknown";

package/dist/workspace-session.js

@@ -0,0 +1,64 @@
+const TOPIC_MARKER = "::topic::";
+export function workspaceSessionForEvent(event, config) {
+    const baseConversationKey = baseConversationForEvent(event, config);
+    if (event.chat_type === "p2p") {
+        return {
+            conversationKey: event.chat_id,
+            baseConversationKey: event.chat_id,
+            kind: "direct",
+            replyInThread: false,
+            startsNewTopic: false,
+        };
+    }
+    const topicRootId = normalizedTopicId(event.root_id) ?? normalizedTopicId(event.thread_id);
+    if (topicRootId) {
+        return {
+            conversationKey: topicConversationKey(event.chat_id, topicRootId),
+            baseConversationKey,
+            kind: "group-topic",
+            replyInThread: true,
+            startsNewTopic: false,
+            topicRootId,
+        };
+    }
+    return {
+        conversationKey: baseConversationKey,
+        baseConversationKey,
+        kind: "group-main",
+        replyInThread: false,
+        startsNewTopic: false,
+    };
+}
+export function workspaceSessionForPrompt(event, config) {
+    const current = workspaceSessionForEvent(event, config);
+    if (current.kind !== "group-main")
+        return current;
+    return {
+        conversationKey: topicConversationKey(event.chat_id, event.message_id),
+        baseConversationKey: current.baseConversationKey,
+        kind: "group-topic",
+        replyInThread: true,
+        startsNewTopic: true,
+        topicRootId: event.message_id,
+    };
+}
+export function baseConversationForEvent(event, config) {
+    if (event.chat_type === "group" && config.groupSessionScope === "member") {
+        return `${event.chat_id}::${event.sender_id}`;
+    }
+    return event.chat_id;
+}
+export function topicConversationKey(chatId, topicRootId) {
+    return `${chatId}${TOPIC_MARKER}${topicRootId}`;
+}
+export function isTopicConversationKey(conversationKey) {
+    return conversationKey.includes(TOPIC_MARKER);
+}
+export function chatIdFromConversationKey(conversationKey) {
+    const boundary = conversationKey.indexOf("::");
+    return boundary >= 0 ? conversationKey.slice(0, boundary) : conversationKey;
+}
+function normalizedTopicId(value) {
+    const normalized = value?.trim();
+    return normalized || undefined;
+}

package/docs/ARCHITECTURE.md

@@ -0,0 +1,54 @@
+# Architecture
+
+Feishu Codex Bridge is a self-hosted, outbound-only control plane. The bridge opens long-lived connections to Feishu and a local Codex app-server; it does not expose SSH, HTTP, or a webhook port from the developer machine.
+
+```mermaid
+flowchart LR
+    F["Feishu messages and CardKit"] --> R["Workspace-session router"]
+    R --> G["Identity, role, chat and project gates"]
+    G --> S["SQLite state, audit and outbox"]
+    S --> Q["Per-workspace-session task queue"]
+    Q --> C["Persistent Codex app-server"]
+    C --> W["Authorized local workspaces"]
+    C --> I["Progress, approvals and questions"]
+    I --> P["Editable Markdown or Card 2.0"]
+    P --> F
+```
+
+## Identity and isolation
+
+- Private chats use the Feishu chat ID as their current workspace-session key.
+- Top-level group controls keep the configured `chat` or `member` isolation policy. A top-level ordinary prompt starts a reply thread whose key is `chat_id::topic::root_message_id`; every later message in that reply thread resolves to the same project, queue, preferences, and Codex thread.
+- A new group topic copies the top-level project and explicit model/reasoning/sandbox preferences once. It never copies an old Codex thread, temporary full-access lease, pending approval, or unfinished task.
+- First-run onboarding is stored per Feishu member and is automatically presented only in private chat, so group work is not interrupted. A single state-driven card renders the device-offline, project-missing, viewer, ready, completed, or dismissed surface; each active surface has one primary action. Team conventions are progressive disclosure rather than a required setup step.
+- Topic history is session-owned, while execution authority remains explicit. Tasks store an immutable initiator and a current controller: control can move only through a group handoff, initiator reclaim, or administrator takeover after role and project ACL checks. Viewers cannot start or control Codex work.
+- Project ACLs are evaluated after project discovery, so a message can never introduce an arbitrary filesystem path.
+- Team dashboards aggregate retained task metadata without rendering prompts, results, diffs, attachments, paths, or raw member IDs.
+
+## Codex lifecycle
+
+One persistent app-server process serves all conversations. The bridge uses native `model/list`, `thread/list`, `thread/resume`, `thread/compact/start`, `turn/start`, `turn/steer`, and `turn/interrupt` methods. A task snapshots its model, reasoning effort, and sandbox mode when it enters the queue, so later settings changes do not mutate an already queued task.
+
+Repository runbooks are parsed as data, not executed as shell scripts. Parameter substitution produces a normal Codex prompt, then the same member, project, model compatibility, sandbox and command policies are applied. A runbook can lower the frozen sandbox but cannot elevate it or pre-authorize external mutations.
+
+## Durability
+
+SQLite WAL stores conversations, tasks, project selections, preferences, onboarding progress, confirmation cards, event deduplication, and device state. A separate outbox table retries text fallbacks. Audit records are bounded to the newest 5,000 entries. Only tasks that can be proven never to have started are restored to the queue; any running, started, or thread-bearing record is interrupted to prevent duplicate commands and file mutations. The task record and CardKit phase are reconciled conservatively at startup. Schema upgrades create a verified SQLite snapshot first and restore it automatically if migration fails.
+
+## Presentation boundary
+
+Questions and read-only analysis own one editable Feishu Markdown reply. That message starts as a compact processing state, is updated in place while Codex works, and becomes a clean final answer without task IDs, model, permission, token, or thread metadata. Routine acknowledgements and validation feedback use the same lightweight native surface.
+
+Native text/post editing uses `PUT /im/v1/messages/:message_id`. Feishu limits one message to 20 edits, so stream deltas are coalesced and progress edits are capped below that limit; a terminal edit is always reserved for the final answer or error state.
+
+Feature cards own controls, project and model settings, approvals, runtime questions, long-running file/code work, reviews, teams, runbooks, and exceptional recovery states. Card rendering remains semantic and state-driven; the durable outbox can fall back to plain text when either Markdown or CardKit delivery fails. This keeps the conversation readable while preserving reliable control for consequential actions.
+
+## Version and adapter boundary
+
+Configuration, persisted state, SQLite, repository policy, runbooks and health files each carry an explicit version. Published packages pin Codex and lark-cli exactly. A safe package upgrade treats the running service as replaceable but the user configuration and data directory as durable: preview, active-task gate, verified backup, doctor, service replacement, health/version verification, then automatic recovery on failure.
+
+Feishu event transport and Codex app-server normalization are internal adapters around the identity/task/policy/persistence domain. They are intentionally not a public plugin SDK in `1.x`; exposing security-critical runtime objects would freeze unsafe implementation details. Future IM or device agents should adapt at these boundaries only after a stable capability, ownership and version-negotiation contract exists.
+
+## Multi-device direction
+
+V5 supports many people on one self-hosted agent node. Multiple machines should not consume the same Feishu application event stream independently because delivery and ownership would be ambiguous. A future hub/agent mode should route tasks through one Feishu-facing hub to outbound-connected device agents, with explicit device identity, project advertisements, end-to-end task ownership, revocation, and no public port on developer laptops.

package/docs/COMPATIBILITY.md

@@ -0,0 +1,55 @@
+# Compatibility and version policy
+
+This page is the release contract for operators and package maintainers. The npm package pins its two runtime integrations so a published bridge does not silently change behavior underneath an installation.
+
+## Current release line
+
+| Component | Supported contract |
+|---|---|
+| Node.js | `>=22` on current macOS or Linux |
+| Codex runtime | @openai/codex `0.144.4` |
+| Feishu runtime | @larksuite/cli `1.0.70` |
+| Configuration | `BRIDGE_CONFIG_VERSION=1` |
+| Persisted bridge state | persisted state v6, migrated on load |
+| SQLite | SQLite schema v1, backed up before migration |
+| Background service | macOS LaunchAgent or Linux systemd user service |
+
+Run `feishu-codex-bridge version` or `feishu-codex-bridge version --json` to print the exact contract installed on a machine.
+
+## Semantic Versioning
+
+- Patch releases fix defects without intentionally changing configuration or persisted-state meaning.
+- Minor releases may add optional settings, cards, commands, and additive stored fields. Existing configuration remains valid.
+- Major releases may remove or redefine a public CLI/configuration contract and must include an explicit migration guide.
+- Prereleases can evolve faster, but never bypass data backup, role checks, or external-action confirmation.
+
+The stable `1.x` promise covers documented CLI commands, configuration keys, runbook schema v1, policy schema v1, and automatic persisted-state migration. Internal TypeScript modules and CardKit payload shapes are not a public plugin API.
+
+## Upgrade and rollback
+
+Preview an upgrade first:
+
+```bash
+npx feishu-codex-console@latest upgrade --config /absolute/path/default.env
+```
+
+The preview is read-only. When no task is actively running, repeat with `--yes`. The command creates a verified SQLite backup, runs the new package’s doctor, stops the old service, installs the new service, and waits for both Feishu consumers to become healthy. Failure triggers a data rollback and, when the previous package location is still available, reinstalls and verifies the previous service.
+
+```bash
+npx feishu-codex-console@latest upgrade \
+  --config /absolute/path/default.env \
+  --yes
+```
+
+Downgrades require `--allow-downgrade`; compatibility is not guaranteed across a major version. Keep the reported backup ID until the new version has handled a real task successfully.
+
+## Dependency updates
+
+Changing either pinned runtime dependency requires:
+
+1. capability-aware unit tests and a clean tarball installation test;
+2. macOS and Linux CI;
+3. a real Feishu message, card callback, Codex task, question, approval, and review pass;
+4. a changelog entry describing any visible model, reasoning, event, or card behavior change.
+
+Experimental Codex capabilities must be feature-detected and cannot be required for the core task loop.