@xfey/tenso 0.1.130

package/README.md

@@ -0,0 +1,85 @@
+# Tenso Host and Local Console
+
+安装入口使用 `@xfey/tenso`，需要 Node.js `>=24 <26` 与 npm `>=11 <12`：
+
+```sh
+npm install -g @xfey/tenso
+tenso
+```
+
+`tenso` 打开本机项目管理页面；`tenso launch` 用于 headless / SSH。用户级桌面入口为
+`Tenso.app` / Tenso XDG entry，浏览器协议为 `tenso://projects`。新包不提供旧命令或协议别名。
+源码 workspace 保持 `@tutti/server`，已有项目继续使用 `TUTTI_HOME` / `~/.tutti`，无需搬迁数据。
+
+当前源码的[协作输出语言](../../docs/system/communication-language.md)由 Host 统一处理：migration `0023`、共享 prompt、Scratchpad／workflow／task 语言继承。通过 Host npm 包交付，需更新项目 Host 才会生效，不依赖 Web 或飞书端新增设置；对照模型的引用语言误判作为已知项保留，不宣称所有模型均稳定通过。
+
+## 作用
+
+`apps/server` 是 Tenso 的项目 host service，也是机器级 Local Console 的进程入口。
+
+`0.1.110` 已发布每次 Chat invocation 的外部资料核验规则、本地／外部 provenance、从实际读取证据派生的回答来源线索，以及隔离多轮模型 smoke；配套 F.3 增量支持群资料确认与普通云盘文件。Web／Relay／Integration 已先行同步，registry byte match 与本机 CLI／Console／原在线 Host 更新通过；实际发布与剩余真人验收状态见同一[按需资料计划](../../docs/roadmap/feishu-on-demand-reference-plan.md)。历史快照不删除，读取线索不继承新鲜度或权限。
+
+已发布的 `0.1.109` 统一验证 Codex `skills/extraRoots/set` / `skills/list` 与实际 `SKILL.md` 文件身份；Chat 的安全阶段日志可通过 invocation ref 关联外部 Reference 读取。候选安装／升级、registry byte match、本机 CLI／Console／测试 Host 更新及更新后 Docx 真人读取闭环已通过；连续更新／同次 pin／附件／失权 live 矩阵仍独立跟踪。证据见[按需资料计划](../../docs/roadmap/feishu-on-demand-reference-plan.md)，不以安装版本代替实际读取证据。
+
+它负责：
+
+- `tenso launch` 后的项目绑定、恢复和接管入口
+- 裸 `tenso` 经 lifecycle lock 启动 / 复用的版本感知 loopback Local Console、独立 invocation context、既有项目 Host 编排，以及可信全局npm安装的idle-only worker / completion自更新交接
+- 首次 eligible 裸 `tenso`、显式 `tenso desktop` 与严格 `tenso://projects` bridge 共用的用户级 desktop integration manager
+- Fastify API、SSE、packaged static Web 产物服务和 server 生命周期
+- SQLite store、migrations、repository 与协作真相读写
+- `control-plane`、scheduler、`procedure-engine`、`run-engine`、`workspace-ops` 与 OpenAI provider 接入
+- host 到 Relay 的连接与工作区加入协作
+- machine-local `standalone | feishu` Project Surface authority，以及Standalone browser session / Feishu trusted integration的双向Host gate
+- Feishu主群聊Chat Assistant canonical response与Host-owned durable outbound handoff intent
+- Feishu 外部来源的按需读取、受控临时 cache、invocation 版本和 SQLite 读取证据；正式 Reference／Standalone 上传与历史 snapshot 保持，见 [external-reference-access.md](../../docs/system/external-reference-access.md)
+
+## 结构
+
+- `src/`：server 代码根目录。
+- `prompts/`：大模型 prompt、指令模板和 Codex 执行模板的统一保存目录。
+- `migrations/`：本地 `tutti.sqlite` 的 SQL migrations。
+- `desktop-assets/`：随 npm package 发布的 macOS AppleScriptObjC handler、白底 squircle desktop PNG / ICNS 与资产说明。
+- `cli-package.mjs`：生成临时 staging `@xfey/tenso` package artifact 的脚本。
+- `prepare-package-assets.mjs`：把 Web build output 和内部 runtime package 复制到 staging package 所需位置。
+- `pack-dry-run.mjs`：构建 staging package 并执行 `npm pack --dry-run --json` 文件列表校验。
+- `smoke-packed-cli.mjs`：安装并验证 packed CLI tarball 的本地 smoke，包括 CLI help / version、runtime deps 和 QR dependency。
+  - 发布时可将 `TUTTI_PACKED_CLI_ARTIFACT_DIR` 指向已存在的独立绝对目录；仅全部 smoke 成功后保留同一已测 `.tgz`，拒绝覆盖同名文件，输出 SHA-256 而不输出临时路径。默认仍清理临时产物。
+- `smoke-desktop-protocol.mjs`：在真实 `~/Applications` 下使用唯一临时 bundle / scheme 验证 macOS 图标点击与 LaunchServices URL event，并在结束时注销、清理。
+- `vitest.config.mjs`：默认快速 Server 测试入口，排除真实 Git、子进程、loopback Host 与 npm preview 集成套件。
+- `vitest.integration.config.mjs`：显式 Server integration 入口；完整保留上述慢套件的行为覆盖。
+- `vitest.artifact-preview.config.mjs`：Artifact hardening smoke 使用的定向 Server 套件入口。
+
+## 当前状态
+
+- 已具备 Fastify host shell、后台 host manager CLI 套件、用户级 desktop integration / strict `tenso://projects` bridge、带 `service status / stop / restart`、卸载前 `shutdown`、并发启动锁、版本替换、strict terminal / desktop browser context、当前 runtime version bootstrap projection、idle / package update cleanup、全机readiness、exact npm global install、跨版本worker / recovery与私有日志的机器级 Local Console、Dev Runner、Host Project API、SSE、SQLite store、collaboration-state、workspace read-state、project timeline observability helper、Control Plane、Procedure / Run、workspace-ops、checks、Relay staged upload finalize、user skills 文件服务、artifacts 可视化产物查看层、current-generation Artifact feedback message / model formatter、Owner-only provider model discovery / update 和 OpenAI / Codex provider 接入。
+- 新 Host project 的空群聊会由 collaboration-state 幂等写入一条 Tutti 欢迎消息；它不经过 browser message command，不触发 `@tutti`、Chat read-state、Scratchpad 或 Timeline / execution 流程。
+- Feishu external source触发的主群聊Chat Assistant回复会在canonical message transaction中建立`platform_outbound_intents`；新clarification / approval和Task terminal也会以稳定event identity进入同一Host durable worker。后台通过当前Host credential交给Relay，`handed_off`只表示Integration durable outbox已接受，不表示飞书最终delivered。
+- Host server 与 Local Console 支持在显式 `webStatic.root` 或 packaged `web/` 存在时服务 Web 静态产物；`/api/*`、SSE、health、host-local control 和 `/local-console/*` API 不被 SPA fallback 吞掉。
+- Root `pack:dry-run` 会先清理 build output、重新构建，再复制 `apps/web/dist` 到 package-local `web/`，生成临时 staging `@xfey/tenso` artifact，并校验 npm pack 文件列表包含 CLI、migrations、prompts、Web index、bundled `@tutti/shared` / `@tutti/relay-client` 以及它们的外部 runtime dependencies，同时排除源码、source map、日志、SQLite、`.env`、`.tutti-dev` 与测试产物。
+- Root `smoke:packed-cli` 同样从干净 build output 生成 staging `@xfey/tenso` tarball、在临时目录安装，并验证 SQLite native binding、`tenso --help` / desktop help / `tenso service --help` / `tenso service status` / `tenso shutdown --help` / `tenso launch --help` / `tenso archive --help` / `tenso --version`、desktop assets、migrations、prompts、Web static index、bundled internal dependencies、bundled external runtime dependencies、CLI QR dependency、仓库锁定的 `@openai/codex` binary 可执行性和临时全局安装路径；该 smoke 不需要 Tutti source repo 存在。
+- 对外发布必须把同一 staging package 通过 `npm pack` 生成的已核验 `.tgz` 交给 `npm publish --auth-type=web`，不得直接发布 staging 目录；npm 的目录发布路径可能重新收集文件并遗漏 staging 内的 bundled dependencies。发布后核对 registry metadata 并回下载；若与已完成安装／CLI smoke 的 candidate 逐字节一致，复用候选证据，不重复安装。未被相同候选覆盖的 registry artifact 仍须补齐安装 smoke。
+- `prompts/` 是所有模型-facing prompt、指令模板和 Codex 执行模板的统一落点；长 prompt 不内联在 TypeScript 中。
+- Host Project API只信任Relay tunnel metadata注入的Surface-matched browser context；direct loopback缺少可信context时不作为浏览器工作区入口。
+- `binding.json.surface_profile`是Project Surface的durable authority，legacy binding默认Standalone；已有project不能通过普通launch或Local Console隐式切换Surface。Relay只保存不可变mirror用于边缘gate。
+- 详细模块落点见 `src/README.md`；logger redaction、command idempotency、schema、provider 与 Codex 边界以 `docs/system/` 对应 canonical 文档为准。
+
+## 约定
+
+- 默认运行在 macOS / Linux host 上。
+- 项目 truth 只在 host server 与正式 repo 中，不进入 Relay。
+- SQLite driver 默认使用 `better-sqlite3`，只有 store adapter 可以直接依赖 driver。
+- 真实仓库任务的正式 adapter 使用 Codex app-server；普通结构化判断走 OpenAI SDK。两者共享同一份 OpenAI provider config。
+- 所有模型-facing prompt 和长指令模板都必须放在 `prompts/`，不得在 TypeScript 中内联长 prompt；模板规范见 [../../docs/system/prompt-template-management.md](../../docs/system/prompt-template-management.md)。
+- 不实现绕过 Relay 的单人工作区路径。
+- packaged / production `tenso launch` 默认连接 `https://tenso.work`；`TUTTI_RELAY_URL` 可覆盖 Relay URL，本地开发 dev runner 默认使用 `http://127.0.0.1:4370`。
+- host 注册使用 machine-local `host_registration_secret`；该 secret 明文只可写入受限权限的 machine-local secret store，不写入目标项目 repo、Git local config 项目身份、SQLite 协作真相或日志，`binding.json` 只保存引用。
+- Relay registration 成功后只把 `relay_project_ref` 写回 machine-local binding；Standalone join URL只在host本机终端或当前host-local control内存状态中展示，不写入binding、runtime endpoint、SQLite协作真相或日志。Feishu project不签发join URL。
+- 普通 `tenso launch` 默认后台运行 host；Standalone完成页展示join URL，Feishu完成页只确认collaboration surface，然后CLI退出。`tenso launch --foreground` 保留前台诊断模式。后台spawn为每次启动生成唯一`startup_attempt_ref`，源码入口会先把`tsx` loader解析为不受目标project cwd影响的绝对URL；spawn、endpoint等待、Relay readiness、内部启动失败与timeout使用同一ref写入`TUTTI_HOME/logs/host.log`。Host HTTP request log 与 Control Plane / Run Pipeline runtime log也写入该文件，不写入目标项目 repo 或常规 CLI stdout。
+- Standalone Host只接受普通`relay_session_context`工作区请求；Feishu Host接受`feishu_platform_session_context` browser请求和固定internal path的`integration_delivery`。三种metadata严格三选一，cross-Surface browser request在进入Fastify业务route前403。Feishu browser只经Relay开放Project / Work / References / Artifacts精确query / command allowlist；References复用Host既有列表、Viewer文本与图片route，Artifacts复用既有projection、bodyless lease与raw preview route，不新增Host truth或upload route。Host仍执行相同actor、command idempotency与Control Plane逻辑。Host outbound使用独立host-control route，不借用browser transport。无状态`/api/v1/openapi.json`诊断仍可生成contract。
+- Reference 和 Skills 上传的最终写入由 Host Project API 完成；Host 只通过 Relay host-control resolve 获取短期 R2 URL 下载 staged object，不接收浏览器 base64 文件正文，也不持久化 presigned URL。
+- Host Project API的browser session context只信任Relay tunnel metadata中的Surface-matched variant；route handler不读取浏览器身份header，也不接受payload内身份字段。Feishu session在兼容projection中使用`client_session.transport = "feishu_platform_session"`，不代表创建Standalone Relay client session。
+- Artifact feedback 仍写入现有 `messages` truth并复用command idempotency；Host只在当前ready generation完全匹配时接受，Anchor技术字段仅保留审计ref，模型上下文使用bounded semantic formatter。
+- Fastify request log、debug log、SSE payload、activity event 和 run result 都必须经过 redaction，不得泄露 provider secret、host registration secret、host connection token、join token、cookie、host 绝对路径或 run workspace path。
+- Repo path metadata policy 与更严格的 Viewer content path policy 已拆分为可测试 helper：Phase 6 Viewer / Reference Files API 继续拒绝 secret-like 内容读取，Run / merge changed paths 可以完整报告结构性安全的 repo-relative 文件名；Phase 7 checks executor 已以 safe npm script discovery、结构化 `spawn`、timeout、stdout / stderr redaction 与 no-shell 执行为首批命令安全边界。
+- 当前源码 package root 仍是 `apps/server`；对外 npm 名由 staging artifact 使用 `@xfey/tenso`，internal workspace dependency bundling、对应外部 runtime dependency bundling 和 packed CLI install smoke 已接通。

package/desktop-assets/README.md

@@ -0,0 +1,18 @@
+# Desktop assets
+
+This directory contains package-owned assets used by the user-level Tenso desktop integration.
+
+- `macos-handler.applescript` is compiled into `~/Applications/Tenso.app` by the packaged CLI. Its
+  AppleScriptObjC handler launches the hidden desktop bridge through `NSTask`, with a fixed
+  `tenso://projects` desktop intent and no shell invocation.
+- `Tenso-app.png` is the 1024px desktop icon: the complete Tenso wordmark centered on a white
+  continuous-corner tile, with transparent outer padding. Linux uses the same visual.
+- `Tenso.icns` contains the standard 16–1024px and Retina representations of that desktop icon.
+
+The source is the user-provided `docs/design/Tenso.svg`, with a generated vector app composition
+at `docs/design/Tenso-app.svg`. Run `node docs/design/generate-brand-assets.mjs` from the repository
+root to regenerate PNG, ICNS, favicon and terminal assets. The script uses the installed `sharp`
+dependency and writes ICNS directly, so generation does not require macOS or an external download.
+
+The assets are shipped inside `@xfey/tenso`; installation never downloads runtime files. They do
+not contain project paths, credentials, tokens, Relay sessions, or Local Console endpoints.

package/desktop-assets/macos-handler.applescript

@@ -0,0 +1,24 @@
+use framework "Foundation"
+use scripting additions
+
+property nodeExecutable : __TUTTI_NODE_EXECUTABLE_STRING__
+property cliEntrypoint : __TUTTI_CLI_ENTRYPOINT_STRING__
+property projectsUrl : "tenso://projects"
+
+on launchTutti(targetUrl)
+  set task to current application's NSTask's alloc()'s init()
+  task's setLaunchPath:nodeExecutable
+  task's setArguments:{cliEntrypoint, "internal", "desktop-open", targetUrl}
+  task's setStandardInput:(current application's NSFileHandle's fileHandleWithNullDevice())
+  task's setStandardOutput:(current application's NSFileHandle's fileHandleWithNullDevice())
+  task's setStandardError:(current application's NSFileHandle's fileHandleWithNullDevice())
+  task's |launch|()
+end launchTutti
+
+on run
+  launchTutti(projectsUrl)
+end run
+
+on open location targetUrl
+  launchTutti(targetUrl)
+end open location

package/dist/approvals/decision-command.d.ts

@@ -0,0 +1,124 @@
+import type { ApprovalRequestId, IdempotencyKey } from "@tutti/shared/ids";
+import type { SqliteDatabase } from "../store/index.js";
+import type { ApprovalDecisionActor, ApprovalRequestManager } from "./manager.js";
+export declare function executeApprovalDecisionCommand(input: {
+    db: SqliteDatabase;
+    approvalManager?: ApprovalRequestManager;
+    commandId: IdempotencyKey;
+    approvalId: ApprovalRequestId;
+    decisionId: string;
+    actor: ApprovalDecisionActor;
+    now?: () => Date;
+}): import("../server-shell/command-idempotency/index.js").ExecuteIdempotentCommandResult<{
+    kind: "interrupted";
+    retry_with_new_command_id: true;
+} | {
+    kind: "accepted";
+} | {
+    kind: "stale_approval";
+} | {
+    kind: "decision_unavailable";
+}, {
+    approval?: {
+        state: "none";
+    } | {
+        state: "pending";
+        request: {
+            expires_at?: string;
+            activity_ref?: string;
+            task_id?: string;
+            reason?: string;
+            file_change?: {
+                paths?: string[];
+                grant_root_label?: string;
+            };
+            permissions?: {
+                network?: {
+                    enabled: boolean;
+                };
+                filesystem?: {
+                    read?: string[];
+                    write?: string[];
+                };
+            };
+            command?: {
+                network?: {
+                    host: string;
+                    protocol: string;
+                };
+                cwd_label?: string;
+                actions?: {
+                    detail?: string;
+                    label: string;
+                }[];
+                text: string;
+            };
+            title: string;
+            summary: string;
+            decisions: {
+                kind: "allow_once" | "allow_session" | "deny" | "cancel";
+                label: string;
+                tone: "neutral" | "primary" | "danger";
+                decision_id: string;
+            }[];
+            approval_id: string;
+            request_kind: "command_execution" | "file_change" | "permissions" | "legacy_exec_command" | "legacy_apply_patch";
+            requested_at: string;
+        };
+    } | {
+        state: "resolved";
+        request: {
+            expires_at?: string;
+            activity_ref?: string;
+            task_id?: string;
+            reason?: string;
+            file_change?: {
+                paths?: string[];
+                grant_root_label?: string;
+            };
+            permissions?: {
+                network?: {
+                    enabled: boolean;
+                };
+                filesystem?: {
+                    read?: string[];
+                    write?: string[];
+                };
+            };
+            command?: {
+                network?: {
+                    host: string;
+                    protocol: string;
+                };
+                cwd_label?: string;
+                actions?: {
+                    detail?: string;
+                    label: string;
+                }[];
+                text: string;
+            };
+            title: string;
+            summary: string;
+            decisions: {
+                kind: "allow_once" | "allow_session" | "deny" | "cancel";
+                label: string;
+                tone: "neutral" | "primary" | "danger";
+                decision_id: string;
+            }[];
+            approval_id: string;
+            request_kind: "command_execution" | "file_change" | "permissions" | "legacy_exec_command" | "legacy_apply_patch";
+            requested_at: string;
+        };
+        resolution: {
+            decided_by?: {
+                display_name: string;
+                account_ref: string;
+            };
+            label: string;
+            outcome: "expired" | "accepted" | "declined" | "cancelled";
+            decision_id: string;
+            decided_at: string;
+        };
+    };
+}>;
+//# sourceMappingURL=decision-command.d.ts.map

package/dist/approvals/decision-command.js

@@ -0,0 +1,20 @@
+import { executeIdempotentCommand } from "../server-shell/command-idempotency/index.js";
+export function executeApprovalDecisionCommand(input) {
+    return executeIdempotentCommand({
+        db: input.db,
+        command_id: input.commandId,
+        command_name: "approval.decide",
+        target_ref: input.approvalId,
+        payload: { decision_id: input.decisionId },
+        ...(input.now === undefined ? {} : { now: input.now }),
+        execute: () => input.approvalManager?.decide({
+            approvalId: input.approvalId,
+            payload: { decision_id: input.decisionId },
+            actor: input.actor,
+        }) ?? {
+            disposition: { kind: "stale_approval" },
+            result: { approval: { state: "none" } },
+        },
+    });
+}
+//# sourceMappingURL=decision-command.js.map

package/dist/approvals/index.d.ts

@@ -0,0 +1,4 @@
+export { ApprovalRequestManager, type ApprovalDecisionActor, type ApprovalRequestManagerOptions, type AwaitApprovalInput, type DecideApprovalInput, } from "./manager.js";
+export { executeApprovalDecisionCommand } from "./decision-command.js";
+export { buildApprovalProjection, type ApprovalAppServerResponse, type ApprovalDecisionRuntime, type ApprovalProjectionBuildResult, type ApprovalProjectionContext, } from "./projections.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/approvals/index.js

@@ -0,0 +1,4 @@
+export { ApprovalRequestManager, } from "./manager.js";
+export { executeApprovalDecisionCommand } from "./decision-command.js";
+export { buildApprovalProjection, } from "./projections.js";
+//# sourceMappingURL=index.js.map

package/dist/approvals/manager.d.ts

@@ -0,0 +1,49 @@
+import type { ApprovalRequestId, IdempotencyKey } from "@tutti/shared/ids";
+import type { ActiveApprovalProjection, ApprovalRequestProjection, DecideApprovalDisposition, DecideApprovalPayload, DecideApprovalResult } from "@tutti/shared/schemas/api";
+import type { CodexAppServerJsonRpcServerRequest } from "../providers/openai/app-server/json-rpc.js";
+import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+import { type ApprovalProjectionContext, type ApprovalAppServerResponse } from "./projections.js";
+export type ApprovalDecisionActor = {
+    account_ref: string;
+    display_name: string;
+};
+export type ApprovalRequestManagerOptions = {
+    events?: WorkspaceEventBus;
+    now?: () => Date;
+    resolvedTtlMs?: number;
+    onPending?: (request: ApprovalRequestProjection) => void;
+};
+export type AwaitApprovalInput = {
+    request: CodexAppServerJsonRpcServerRequest;
+    context?: Partial<Omit<ApprovalProjectionContext, "requestedAt">>;
+    timeoutMs: number;
+};
+export type DecideApprovalInput = {
+    approvalId: ApprovalRequestId;
+    payload: DecideApprovalPayload;
+    commandId?: IdempotencyKey;
+    actor?: ApprovalDecisionActor;
+};
+export declare class ApprovalRequestManager {
+    private readonly events;
+    private readonly now;
+    private readonly resolvedTtlMs;
+    private readonly onPending;
+    private active;
+    private resolved;
+    private resolvedTimer;
+    constructor(options?: ApprovalRequestManagerOptions);
+    getActiveApproval(): ActiveApprovalProjection;
+    awaitApproval(input: AwaitApprovalInput): Promise<ApprovalAppServerResponse>;
+    decide(input: DecideApprovalInput): {
+        disposition: DecideApprovalDisposition;
+        result?: DecideApprovalResult;
+    };
+    clearPending(response?: ApprovalAppServerResponse): void;
+    dispose(): void;
+    private resolveActive;
+    private clearResolvedAfterTtl;
+    private clearResolved;
+    private publish;
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/approvals/manager.js

@@ -0,0 +1,189 @@
+import { buildApprovalProjection, } from "./projections.js";
+const DEFAULT_RESOLVED_TTL_MS = 3000;
+function approvalInvalidates() {
+    return [
+        { kind: "approval" },
+        { kind: "execution_status" },
+        { kind: "bootstrap" },
+    ];
+}
+function timeoutError() {
+    return {
+        code: "approval_timeout",
+        message: "Approval request timed out.",
+    };
+}
+function cancelledError() {
+    return {
+        code: "approval_cancelled",
+        message: "Approval request was cancelled.",
+    };
+}
+export class ApprovalRequestManager {
+    events;
+    now;
+    resolvedTtlMs;
+    onPending;
+    active = null;
+    resolved = null;
+    resolvedTimer;
+    constructor(options = {}) {
+        this.events = options.events;
+        this.now = options.now ?? (() => new Date());
+        this.resolvedTtlMs = options.resolvedTtlMs ?? DEFAULT_RESOLVED_TTL_MS;
+        this.onPending = options.onPending;
+    }
+    getActiveApproval() {
+        if (this.active !== null) {
+            return this.active.projection;
+        }
+        if (this.resolved !== null) {
+            return this.resolved;
+        }
+        return { state: "none" };
+    }
+    async awaitApproval(input) {
+        if (this.active !== null) {
+            return {
+                kind: "error",
+                error: {
+                    code: "approval_already_pending",
+                    message: "Another approval request is already pending.",
+                },
+            };
+        }
+        this.clearResolved(false);
+        const requestedAt = this.now();
+        const expiresAt = new Date(requestedAt.getTime() + input.timeoutMs);
+        const build = buildApprovalProjection(input.request, {
+            ...input.context,
+            requestedAt: requestedAt.toISOString(),
+            expiresAt: expiresAt.toISOString(),
+        });
+        if (build === null) {
+            return {
+                kind: "error",
+                error: {
+                    code: "unsupported_approval_request",
+                    message: `Unsupported approval request: ${input.request.method}`,
+                },
+            };
+        }
+        return await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                if (this.active?.projection.request.approval_id !== build.request.approval_id) {
+                    return;
+                }
+                this.resolveActive({
+                    decisionId: "timeout",
+                    label: "Timed out",
+                    outcome: "expired",
+                    response: { kind: "error", error: timeoutError() },
+                });
+            }, input.timeoutMs);
+            this.active = {
+                projection: {
+                    state: "pending",
+                    request: build.request,
+                },
+                decisions: build.decisions,
+                resolve,
+                timer,
+            };
+            try {
+                this.onPending?.(build.request);
+            }
+            catch {
+                // Approval correctness and the app-server response must not depend on outbound notice
+                // capture. The platform worker records bounded diagnostics after successful capture.
+            }
+            this.publish(this.active.projection);
+        });
+    }
+    decide(input) {
+        const active = this.active;
+        if (active === null || active.projection.request.approval_id !== input.approvalId) {
+            return {
+                disposition: { kind: "stale_approval" },
+                result: { approval: this.getActiveApproval() },
+            };
+        }
+        const decision = active.decisions.get(input.payload.decision_id);
+        if (decision === undefined) {
+            return {
+                disposition: { kind: "decision_unavailable" },
+                result: { approval: active.projection },
+            };
+        }
+        this.resolveActive(decision, input.actor);
+        return {
+            disposition: { kind: "accepted" },
+            result: { approval: this.getActiveApproval() },
+        };
+    }
+    clearPending(response = { kind: "error", error: cancelledError() }) {
+        const active = this.active;
+        if (active === null) {
+            return;
+        }
+        clearTimeout(active.timer);
+        this.active = null;
+        active.resolve(response);
+        this.publish(this.getActiveApproval());
+    }
+    dispose() {
+        this.clearPending();
+        this.clearResolved(false);
+    }
+    resolveActive(decision, actor) {
+        const active = this.active;
+        if (active === null) {
+            return;
+        }
+        clearTimeout(active.timer);
+        this.active = null;
+        this.resolved = {
+            state: "resolved",
+            request: active.projection.request,
+            resolution: {
+                decision_id: decision.decisionId,
+                label: decision.label,
+                outcome: decision.outcome,
+                decided_at: this.now().toISOString(),
+                ...(actor === undefined ? {} : { decided_by: actor }),
+            },
+        };
+        active.resolve(decision.response);
+        this.publish(this.resolved);
+        this.clearResolvedAfterTtl();
+    }
+    clearResolvedAfterTtl() {
+        if (this.resolvedTimer !== undefined) {
+            clearTimeout(this.resolvedTimer);
+        }
+        this.resolvedTimer = setTimeout(() => {
+            this.clearResolved(true);
+        }, this.resolvedTtlMs);
+    }
+    clearResolved(publish) {
+        if (this.resolvedTimer !== undefined) {
+            clearTimeout(this.resolvedTimer);
+            this.resolvedTimer = undefined;
+        }
+        if (this.resolved === null) {
+            return;
+        }
+        this.resolved = null;
+        if (publish) {
+            this.publish(this.getActiveApproval());
+        }
+    }
+    publish(approval) {
+        this.events?.publish({
+            event_type: "approval.changed",
+            payload: { approval },
+            invalidates: approvalInvalidates(),
+        });
+    }
+}
+//# sourceMappingURL=manager.js.map

package/dist/approvals/projections.d.ts

@@ -0,0 +1,33 @@
+import { type ActivityRef, type TaskId } from "@tutti/shared/ids";
+import type { ApprovalRequestProjection, ApprovalResolutionOutcome } from "@tutti/shared/schemas/api";
+import type { CodexAppServerJsonRpcError, CodexAppServerJsonRpcServerRequest } from "../providers/openai/app-server/json-rpc.js";
+export type ApprovalAppServerResponse = {
+    kind: "result";
+    result: unknown;
+} | {
+    kind: "error";
+    error: CodexAppServerJsonRpcError;
+};
+export type ApprovalDecisionRuntime = {
+    decisionId: string;
+    label: string;
+    outcome: ApprovalResolutionOutcome;
+    response: ApprovalAppServerResponse;
+};
+export type ApprovalProjectionBuildResult = {
+    request: ApprovalRequestProjection;
+    decisions: Map<string, ApprovalDecisionRuntime>;
+};
+export type ApprovalProjectionContext = {
+    taskId?: TaskId;
+    activityRef?: ActivityRef;
+    requestedAt: string;
+    expiresAt?: string;
+    workspaceRoot?: string;
+    codexHome?: string;
+    tuttiHome?: string;
+    builtInSkillsRoot?: string;
+    sensitiveValues?: readonly string[];
+};
+export declare function buildApprovalProjection(request: CodexAppServerJsonRpcServerRequest, context: ApprovalProjectionContext): ApprovalProjectionBuildResult | null;
+//# sourceMappingURL=projections.d.ts.map