openshain 0.2.0 → 0.4.0

package/dist/tui/lines.js

@@ -1,5 +1,6 @@
 import { displayWidth } from "../format.js";
 import { logoSegments } from "./banner.js";
+import { markdownRows } from "./markdown.js";
 /** What starts a line of each kind. The continuation lines of a wrapped entry are indented to match. */
 const MARKERS = {
     user: "> ",
@@ -31,6 +32,19 @@ export function wrapText(text, width) {
     }
     return out;
 }
+/**
+ * The rows of one reply, kept until the entry goes or the width changes. The screen redraws
+ * every entry whenever a line is added, and reading markdown is the expensive part of that.
+ */
+const drawn = new WeakMap();
+export function rowsFor(entry, width) {
+    const held = drawn.get(entry);
+    if (held && held.width === width)
+        return held.rows;
+    const rows = markdownRows(entry.text, width);
+    drawn.set(entry, { width, rows });
+    return rows;
+}
 /** A blank row goes before an entry that starts something new: a message, a reply, a notice, a question. */
 function startsBlock(kind, previous) {
     if (previous === undefined)
@@ -52,14 +66,28 @@ export function screenLines(entries, width) {
             lines.push({ kind: "blank", text: "" });
         if (entry.kind === "logo") {
             // Never wrapped: a cut row of the wordmark reads better than a broken one.
-            lines.push({ kind: "logo", text: entry.text, segments: logoSegments(entry.text) });
+            lines.push({ kind: "logo", text: entry.text, spans: logoSegments(entry.text) });
             previous = entry.kind;
             continue;
         }
         const marker = MARKERS[entry.kind];
         const indent = " ".repeat(displayWidth(marker));
-        const body = wrapText(entry.text, Math.max(8, width - displayWidth(marker)));
-        for (const [i, text] of body.entries()) {
+        const room = Math.max(8, width - displayWidth(marker));
+        if (entry.kind === "assistant") {
+            // The reply is written in markdown; the screen draws it rather than showing its marks.
+            for (const [i, row] of rowsFor(entry, room).entries()) {
+                // A row with nothing on it is drawn as an empty one: no marker, no indent, no pieces.
+                if (row.length === 0) {
+                    lines.push({ kind: entry.kind, text: "" });
+                    continue;
+                }
+                const spans = [{ text: i === 0 ? marker : indent }, ...row];
+                lines.push({ kind: entry.kind, text: spans.map((s) => s.text).join(""), spans });
+            }
+            previous = entry.kind;
+            continue;
+        }
+        for (const [i, text] of wrapText(entry.text, room).entries()) {
             lines.push({ kind: entry.kind, text: (i === 0 ? marker : indent) + text });
         }
         previous = entry.kind;

package/dist/tui/markdown.d.ts

@@ -0,0 +1,15 @@
+/** A piece of a row that carries one style. A row is a list of these, drawn left to right. */
+export interface Span {
+    text: string;
+    color?: string;
+    bold?: boolean;
+    italic?: boolean;
+    dim?: boolean;
+    strikethrough?: boolean;
+}
+/**
+ * A reply as rows of styled pieces. The model writes markdown, so the screen shows the emphasis
+ * and the structure instead of the characters that mark them. What this does not draw yet is
+ * shown as it was written, never dropped.
+ */
+export declare function markdownRows(source: string, width: number): Span[][];

package/dist/tui/markdown.js

@@ -0,0 +1,199 @@
+import { marked } from "marked";
+import { displayWidth } from "../format.js";
+/** What each part of a reply looks like on the screen. */
+const STYLE = {
+    heading: { bold: true, color: "cyan" },
+    code: { color: "green" },
+    link: { color: "blue" },
+    quote: { dim: true },
+    rule: { dim: true },
+};
+const QUOTE_MARKER = "▎ ";
+const CODE_MARKER = "│ ";
+const BULLETS = ["•", "◦", "‣"];
+function styled(text, style) {
+    return { text, ...style };
+}
+/** The inline tokens of one block, flattened into styled pieces. */
+function inline(tokens, style) {
+    if (!tokens)
+        return [];
+    const spans = [];
+    for (const token of tokens) {
+        switch (token.type) {
+            case "strong":
+                spans.push(...inline(token.tokens, { ...style, bold: true }));
+                break;
+            case "em":
+                spans.push(...inline(token.tokens, { ...style, italic: true }));
+                break;
+            case "del":
+                spans.push(...inline(token.tokens, { ...style, strikethrough: true }));
+                break;
+            case "codespan":
+                spans.push(styled(token.text, { ...style, ...STYLE.code }));
+                break;
+            case "link": {
+                const link = token;
+                spans.push(...inline(link.tokens, style));
+                // The label alone hides where the link goes, so the address follows it.
+                if (link.href && link.href !== textOf(link.tokens)) {
+                    spans.push(styled(` (${link.href})`, { ...style, ...STYLE.link }));
+                }
+                break;
+            }
+            case "br":
+                spans.push(styled("\n", style));
+                break;
+            case "escape":
+            case "text":
+                spans.push(...(token.tokens
+                    ? inline(token.tokens, style)
+                    : [styled(token.text, style)]));
+                break;
+            default:
+                spans.push(styled(token.raw, style));
+        }
+    }
+    return spans;
+}
+function textOf(tokens) {
+    return inline(tokens, {})
+        .map((s) => s.text)
+        .join("");
+}
+/**
+ * Breaks styled pieces into rows no wider than `width` display columns, the way the rest of the
+ * screen breaks plain text: at the character, so Japanese wraps where it should. Rows after the
+ * first start with `hanging`, which keeps a list item under its own marker.
+ */
+function wrap(spans, width, hanging = "") {
+    const limit = Math.max(4, width);
+    const rows = [];
+    let row = [];
+    let used = 0;
+    const indent = () => (hanging === "" ? [] : [{ text: hanging }]);
+    const start = () => {
+        rows.push(row);
+        row = indent();
+        used = displayWidth(hanging);
+    };
+    for (const span of spans) {
+        for (const [i, part] of span.text.split("\n").entries()) {
+            // A line break inside a block starts a row of its own.
+            if (i > 0)
+                start();
+            let piece = "";
+            for (const ch of part) {
+                const w = displayWidth(ch);
+                if (used + w > limit && (row.length > 0 || piece !== "")) {
+                    if (piece !== "")
+                        row.push({ ...span, text: piece });
+                    piece = "";
+                    start();
+                }
+                piece += ch;
+                used += w;
+            }
+            if (piece !== "")
+                row.push({ ...span, text: piece });
+        }
+    }
+    rows.push(row);
+    return rows;
+}
+/** Puts `prefix` in front of every row, for a quote bar or a code bar. */
+function prefixed(rows, prefix) {
+    return rows.map((row) => [prefix, ...row]);
+}
+function blockRows(tokens, width) {
+    const rows = [];
+    for (const token of tokens) {
+        switch (token.type) {
+            case "space":
+                rows.push([]);
+                break;
+            case "heading":
+                rows.push(...wrap(inline(token.tokens, STYLE.heading), width));
+                break;
+            case "paragraph":
+            case "text":
+                rows.push(...wrap(inline(token.tokens ?? [], {}), width));
+                break;
+            case "code": {
+                const marker = styled(CODE_MARKER, STYLE.quote);
+                const body = token.text.split("\n");
+                for (const line of body) {
+                    rows.push(...prefixed(wrap([styled(line, STYLE.code)], width - 2), marker));
+                }
+                break;
+            }
+            case "blockquote": {
+                const inner = blockRows(token.tokens ?? [], width - 2);
+                rows.push(...prefixed(inner, styled(QUOTE_MARKER, STYLE.quote)));
+                break;
+            }
+            case "list":
+                rows.push(...listRows(token, width, 0));
+                break;
+            case "hr":
+                rows.push([styled("─".repeat(Math.max(4, width)), STYLE.rule)]);
+                break;
+            case "table":
+                // Aligning columns is its own piece of work; until then the source rows are shown as
+                // they were written, so nothing the model put in the table is lost.
+                for (const line of token.raw.trimEnd().split("\n")) {
+                    rows.push(...wrap([{ text: line }], width));
+                }
+                break;
+            default:
+                for (const line of (token.raw ?? "").trimEnd().split("\n")) {
+                    rows.push(...wrap([{ text: line }], width));
+                }
+        }
+    }
+    return rows;
+}
+function listRows(list, width, depth) {
+    const rows = [];
+    let number = Number(list.start || 1);
+    for (const item of list.items) {
+        const marker = list.ordered ? `${number++}. ` : `${BULLETS[depth % BULLETS.length]} `;
+        const indent = " ".repeat(displayWidth(marker));
+        const inner = [];
+        for (const token of item.tokens) {
+            if (token.type === "list") {
+                inner.push(...listRows(token, width - displayWidth(marker), depth + 1));
+            }
+            else {
+                inner.push(...blockRows([token], width - displayWidth(marker)));
+            }
+        }
+        for (const [i, row] of inner.entries()) {
+            rows.push([{ text: i === 0 ? marker : indent }, ...row]);
+        }
+    }
+    return rows;
+}
+/**
+ * How much of a reply is read as markdown. Reading it costs more than the square of its length
+ * (10,000 characters take about 0.14 seconds, 20,000 about 0.46, 140,000 over a minute), and the
+ * screen draws on one thread, so a longer reply would hold it. Above this the reply is shown as
+ * plain text: every character is still there, with its marks.
+ */
+const MAX_SOURCE = 20_000;
+/**
+ * A reply as rows of styled pieces. The model writes markdown, so the screen shows the emphasis
+ * and the structure instead of the characters that mark them. What this does not draw yet is
+ * shown as it was written, never dropped.
+ */
+export function markdownRows(source, width) {
+    if (source.length > MAX_SOURCE)
+        return wrap([{ text: source }], width);
+    const rows = blockRows(marked.lexer(source), width);
+    while (rows.length > 0 && (rows[0]?.length ?? 0) === 0)
+        rows.shift();
+    while (rows.length > 0 && (rows.at(-1)?.length ?? 0) === 0)
+        rows.pop();
+    return rows.length > 0 ? rows : [[]];
+}

package/dist/usage.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEvent } from "@openshain/core";
+import { type AnyEvent } from "@openshain/core";
 export interface UsageSummary {
     modelCalls: number;
     toolCalls: number;

package/dist/usage.js

@@ -1,4 +1,4 @@
-import { countToolCalls } from "@openshain/agent";
+import { countToolCalls } from "@openshain/core";
 /** Totals over a work's events: calls and tokens. */
 export function summarizeUsage(events) {
     const summary = {

package/dist/workspace.js

@@ -12,7 +12,7 @@ export async function findWorkspace(start) {
         catch {
             const parent = dirname(dir);
             if (parent === dir) {
-                throw new OpenshainError("config", `${CONFIG_FILE_NAME} が見つかりません。${resolve(start)} から上に向かって探しました。openshain init で作れます。`);
+                throw new OpenshainError("config", `${CONFIG_FILE_NAME} が見つかりません。${resolve(start)} から上に向かって探しました。openshain init で作成します。`);
             }
             dir = parent;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openshain",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Reference CLI of the openshain agent harness",
   "keywords": [
     "openshain",
@@ -30,7 +30,8 @@
     "!src/**/*.test.ts",
     "!src/**/*.test.tsx",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "NOTICE"
   ],
   "exports": {
     ".": {
@@ -40,7 +41,7 @@
     }
   },
   "bin": {
-    "openshain": "./dist/bin.js"
+    "openshain": "dist/bin.js"
   },
   "scripts": {
     "build": "../../node_modules/.bin/tsc -p tsconfig.build.json",
@@ -48,11 +49,12 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",
-    "@openshain/agent": "0.2.0",
-    "@openshain/core": "0.2.0",
-    "@openshain/mcp": "0.2.0",
-    "@openshain/tools": "0.2.0",
+    "@openshain/agent": "0.4.0",
+    "@openshain/core": "0.4.0",
+    "@openshain/mcp": "0.4.0",
+    "@openshain/tools": "0.4.0",
     "ink": "7.1.1",
+    "marked": "18.0.12",
     "react": "19.2.8"
   },
   "devDependencies": {

package/src/bin.ts

@@ -1,14 +1,12 @@
 #!/usr/bin/env node
-import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
 import { anthropicProvider, openaiCompatibleProvider } from "@openshain/agent";
 import { isOpenshainError, type RuntimeProviders } from "@openshain/core";
 import { standardTools } from "@openshain/tools";
 import { init } from "./commands/init.ts";
 import { mcp } from "./commands/mcp.ts";
-import { run } from "./commands/run.ts";
 import { toolsList } from "./commands/tools.ts";
-import { workList, workResume, workShow } from "./commands/work.ts";
+import { workList, workShow } from "./commands/work.ts";
 import { plain } from "./format.ts";
 import { errorLabel } from "./labels.ts";
 import { startTui } from "./tui/index.ts";
@@ -17,11 +15,9 @@ import { findWorkspace } from "./workspace.ts";
 const USAGE = `使い方:
   openshain                      端末で対話を始める
   openshain init                 openshain.yaml のひな型を書く
-  openshain run "<依頼>"          依頼を Work として進める
   openshain tools list           使える Tool の一覧
   openshain work list            Work の一覧
   openshain work show <id>       Work の詳細
-  openshain work resume <id>     途中で止まった Work を続ける
   openshain mcp                  MCP Server を stdio で起動する
 
   --workspace <dir>              起点のディレクトリ。省略時はカレントディレクトリ
@@ -67,17 +63,6 @@ async function main(argv: string[]): Promise<number> {
     case "init":
       await init({ workspaceRoot: values.workspace ?? process.cwd(), write });
       return 0;
-    case "run": {
-      const objective = rest.join(" ").trim();
-      if (!objective) {
-        write('依頼の文を指定してください。openshain run "今月の経理を進めて" のように。');
-        return 2;
-      }
-      const workspaceRoot = await findWorkspace(values.workspace ?? process.cwd());
-      return withTerminal((ask) =>
-        run({ workspaceRoot, providers, objective, write, ...(ask && { ask }) }),
-      );
-    }
     case "mcp": {
       const workspaceRoot = await findWorkspace(values.workspace ?? process.cwd());
       await mcp({ workspaceRoot, providers });
@@ -95,7 +80,7 @@ async function main(argv: string[]): Promise<number> {
     case "work": {
       const sub = rest[0];
       const id = rest[1] ?? "";
-      if (!(sub === "list" || ((sub === "show" || sub === "resume") && id))) {
+      if (!(sub === "list" || (sub === "show" && id))) {
         write(USAGE);
         return 2;
       }
@@ -104,13 +89,8 @@ async function main(argv: string[]): Promise<number> {
         await workList({ workspaceRoot, write });
         return 0;
       }
-      if (sub === "show") {
-        await workShow({ workspaceRoot, id, write });
-        return 0;
-      }
-      return withTerminal((ask) =>
-        workResume({ workspaceRoot, providers, id, write, ...(ask && { ask }) }),
-      );
+      await workShow({ workspaceRoot, id, write });
+      return 0;
     }
     default:
       write(`不明なコマンド ${command}`);
@@ -119,20 +99,6 @@ async function main(argv: string[]): Promise<number> {
   }
 }
 
-/** Runs `fn` with a way to ask the person when a terminal is there to answer; otherwise without one. */
-async function withTerminal(
-  fn: (ask?: (question: string) => Promise<string>) => Promise<number>,
-): Promise<number> {
-  // Without a terminal there is no one to answer; the work waits instead.
-  if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) return fn();
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    return await fn((question) => rl.question(`${plain(question)}\n> `));
-  } finally {
-    rl.close();
-  }
-}
-
 main(process.argv.slice(2)).then(
   (code) => process.exit(code),
   (err: unknown) => {

package/src/commands/init.ts

@@ -21,7 +21,7 @@ profession:
   id: generic
   # model への指示。100,000 文字まで
   instructions: |
-    あなたはこの会社の事務担当です。依頼された作業を、workspace 内のファイルだけを使って進めてください。
+    あなたはこの会社の一般事務の社員エージェントです。依頼された作業を、workspace 内のファイルだけを使って進めてください。
 model:
   provider: anthropic      # anthropic | openai-compatible
   model: claude-opus-5
@@ -52,7 +52,7 @@ export const MCP_TEMPLATE = `${JSON.stringify(
 /** What an outside agent reads before working in the folder. Codex reads AGENTS.md; Claude Code reads it through CLAUDE.md. */
 export const AGENTS_TEMPLATE = `# この会社フォルダで働くエージェントへ
 
-このフォルダは openshain の Company Workspace です。この指示は、Claude Code や Codex のような外部のエージェントが MCP 経由でこのフォルダを扱うときのものです。\`openshain run\` で Runtime 自身が動くときは、Work の作成と完了を Runtime が行うので、下の work_* の手順は当てはまりません。
+このフォルダは openshain の Company Workspace です。この指示は、Claude Code や Codex のような外部のエージェントが MCP 経由でこのフォルダを扱うときのものです。openshain の対話型 CLI も同じ手順で Runtime を使います。
 
 会社のファイルの読み書きと集計は openshain の MCP tool で行います。Claude Code や Codex 自身の Read、Write、Bash は会社のファイルには使いません。Runtime を通らなかった操作は記録に残らないためです。
 
@@ -60,7 +60,8 @@ export const AGENTS_TEMPLATE = `# この会社フォルダで働くエージェ
 - ファイルは \`fs_list\`、\`fs_search\`、\`fs_read\`、\`csv_read\`、\`markdown_read\` で見る。合計や件数は \`csv_aggregate\` に任せ、自分で合計しない
 - 書くときは \`fs_write\` か \`csv_write\`
 - 終わったら \`work_complete\` に、何をしたかと、書いたファイルを渡す。続けられないときは \`work_fail\`
-- \`openshain.yaml\` と \`work/\` は Runtime のもの。変更しない
+- \`openshain.yaml\`、\`work/\`、\`principals/\`、\`authority/\` は Runtime のもの。変更しない
+- 呼び出しの結果が \`pending\` なら、会社の権限の規則がその呼び出しを止めている。承認は会社の人が openshain の画面で決める。自分で \`approval_decide\` や \`review_decide\` を呼んで通さない。人に伝えて、決まるまで別の作業をする
 `;
 
 export const CLAUDE_TEMPLATE = "@AGENTS.md\n";
@@ -110,7 +111,7 @@ export async function init({ workspaceRoot, write }: InitOptions): Promise<void>
     }
   }
   write(
-    "company と principal を自分の会社に合わせ、api_key_env に書いた環境変数を設定してから openshain run を実行してください。",
+    "company と principal を自分の会社に合わせ、api_key_env に書いた環境変数を設定してから openshain を実行してください。",
   );
 }
 
@@ -123,10 +124,10 @@ async function addToMcpConfig(path: string): Promise<string> {
   try {
     parsed = JSON.parse(await readFile(path, "utf8"));
   } catch {
-    return `${path} はすでにあり、JSON として読めないので変更しません。openshain を手で登録してください。`;
+    return `${path} はすでにあり、JSON として読めないので変更しません。openshain を手動で登録してください。`;
   }
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-    return `${path} はすでにあり、形が違うので変更しません。openshain を手で登録してください。`;
+    return `${path} はすでにあり、形が違うので変更しません。openshain を手動で登録してください。`;
   }
   const config = parsed as { mcpServers?: unknown };
   const servers =

package/src/commands/tools.ts

@@ -1,5 +1,10 @@
-import { ASK_USER, RUNTIME_PROVIDER_ID } from "@openshain/agent";
-import { createToolRegistry, loadConfig, type RuntimeProviders } from "@openshain/core";
+import {
+  ASK_USER,
+  createToolRegistry,
+  loadConfig,
+  RUNTIME_PROVIDER_ID,
+  type RuntimeProviders,
+} from "@openshain/core";
 
 export interface ToolsListOptions {
   workspaceRoot: string;

package/src/commands/work.ts

@@ -1,19 +1,16 @@
-import { pendingQuestions } from "@openshain/agent";
 import {
   type AnyEvent,
-  createRuntime,
   type Event,
-  isTerminal,
   parseWorkId,
-  type RuntimeProviders,
-  SESSION_WORK_TYPE,
+  pendingApprovals,
+  pendingQuestions,
   type Work,
   WorkStore,
 } from "@openshain/core";
 import { describeInput, padDisplay } from "../format.ts";
 import { errorLabel, failureLabel, rejectionLabel, statusLabel } from "../labels.ts";
+import { nextActor } from "../report.ts";
 import { formatUsage, summarizeUsage } from "../usage.ts";
-import { type DriveOptions, drive, nextActor } from "./run.ts";
 
 export interface WorkListOptions {
   workspaceRoot: string;
@@ -24,7 +21,7 @@ export interface WorkListOptions {
 export async function workList({ workspaceRoot, write }: WorkListOptions): Promise<void> {
   const { works, problems } = await new WorkStore(workspaceRoot).list();
   if (works.length === 0 && problems.length === 0) {
-    write('Work はまだありません。openshain run "<依頼>" で始められます。');
+    write("Work はまだありません。openshain で社員エージェントに依頼すると始まります。");
     return;
   }
   for (const work of works) {
@@ -75,6 +72,12 @@ export function describeWork(work: Work, events: AnyEvent[]): string[] {
   if (work.status === "waiting_input") {
     for (const { question } of pendingQuestions(events)) lines.push(`質問      ${question}`);
   }
+  if (work.status === "waiting_approval") {
+    for (const a of pendingApprovals(events)) {
+      const who = a.kind === "review" ? `${a.reviewer?.role ?? "資格者"}の判断待ち` : "承認待ち";
+      lines.push(`${who}  ${a.call.name} ${describeInput(a.call.input)}  (${a.approvalId})`);
+    }
+  }
 
   const calls = toolLines(events);
   if (calls.length > 0) {
@@ -86,33 +89,6 @@ export function describeWork(work: Work, events: AnyEvent[]): string[] {
   return lines;
 }
 
-export interface WorkResumeOptions extends DriveOptions {
-  workspaceRoot: string;
-  providers: RuntimeProviders;
-  id: string;
-}
-
-/** Continues a work that stopped before its end, answering its questions when the caller can. */
-export async function workResume(options: WorkResumeOptions): Promise<number> {
-  const workId = parseWorkId(options.id);
-  const work = await new WorkStore(options.workspaceRoot).get(workId);
-  if (work.type === SESSION_WORK_TYPE) {
-    options.write(
-      `${work.id} は会話の記録のため、再開できません。会話は openshain で始め直してください。`,
-    );
-    return 1;
-  }
-  if (isTerminal(work.status)) {
-    options.write(`${work.id} は${statusLabel(work.status)}のため、再開できません。`);
-    return 1;
-  }
-  const runtime = await createRuntime({
-    workspaceRoot: options.workspaceRoot,
-    providers: options.providers,
-  });
-  return drive(runtime, workId, options);
-}
-
 /** One line per tool call, in log order, with its outcome when it was rejected or failed. */
 function toolLines(events: AnyEvent[]): string[] {
   const lines = new Map<string, string>();

package/src/index.ts

@@ -8,22 +8,12 @@ export {
   MCP_TEMPLATE,
 } from "./commands/init.ts";
 export { type McpOptions, mcp } from "./commands/mcp.ts";
-export {
-  type DriveOptions,
-  drive,
-  nextActor,
-  type RunOptions,
-  report,
-  run,
-} from "./commands/run.ts";
 export { type ToolsListOptions, toolsList } from "./commands/tools.ts";
 export {
   describeWork,
   type WorkListOptions,
-  type WorkResumeOptions,
   type WorkShowOptions,
   workList,
-  workResume,
   workShow,
 } from "./commands/work.ts";
 export {
@@ -36,5 +26,6 @@ export {
   STATUS_LABELS,
   statusLabel,
 } from "./labels.ts";
+export { nextActor, progressLine, report } from "./report.ts";
 export { formatUsage, summarizeUsage, type UsageSummary } from "./usage.ts";
 export { findWorkspace } from "./workspace.ts";

package/src/labels.ts

@@ -1,5 +1,4 @@
-import type { FailureReason } from "@openshain/agent";
-import type { ErrorCode, ToolRejectionCode, WorkStatus } from "@openshain/core";
+import type { ErrorCode, FailureReason, ToolRejectionCode, WorkStatus } from "@openshain/core";
 
 /** The words shown for a work's status. The log keeps the original value. */
 export const STATUS_LABELS: Record<WorkStatus, string> = {
@@ -28,6 +27,9 @@ export const REJECTION_LABELS: Record<ToolRejectionCode, string> = {
   reserved_path: "予約されたパス",
   outside_workspace: "workspace の外",
   invalid_path: "不正なパス",
+  limit_reached: "Tool 呼び出しの上限",
+  denied: "権限の表で不許可",
+  rejected_by_person: "承認されなかった",
 };
 
 /** A heading for a runtime error, before the original message. */