openshain 0.2.0 → 0.4.0

package/dist/tui/controller.d.ts

@@ -1,5 +1,7 @@
-import { type Runtime, type RuntimeProviders, type WorkId } from "@openshain/core";
+import { type ApprovalChoice } from "@openshain/agent";
+import { type RuntimeProviders, type WorkId, WorkStore } from "@openshain/core";
 import { statusLabel } from "../labels.ts";
+import { type PreviewLine } from "../preview.ts";
 /** logo and banner are the rows shown once when the screen opens: the wordmark, the version, the folder. */
 export type EntryKind = "user" | "assistant" | "progress" | "notice" | "question" | "line" | "logo" | "banner";
 export interface Entry {
@@ -16,6 +18,22 @@ export interface ControllerState {
     busy: boolean;
     /** A question a work is asking; the next line the person types answers it. */
     question?: string;
+    /** A call held for approval; the person picks one of its choices before the work goes on. */
+    approval?: {
+        approvalId: string;
+        title: string;
+        ruleId: string;
+        preview: PreviewLine[];
+        choices: {
+            key: ApprovalChoice | "reject_with_reason";
+            label: string;
+        }[];
+        at: number;
+    };
+    /** After "no, and tell the agent why": the next line the person types is that reason. */
+    reason?: string;
+    /** Lines typed while the screen was busy. They are sent in order once it is free. */
+    queued: string[];
     closed: boolean;
     status: {
         company: string;
@@ -41,16 +59,23 @@ export interface Controller {
     submit(line: string): Promise<void>;
     /** Ctrl-C: stops the running work, taking back a question it waits on; false when nothing was running. */
     interrupt(): boolean;
+    /** Moves the highlight in the approval choices. */
+    moveApproval(delta: number): void;
+    /** Answers the approval being shown: the highlighted choice, or the one given. */
+    decideApproval(choice?: ApprovalChoice | "reject_with_reason"): void;
     /** Stops whatever is running, then ends the session. A second call waits for the same close. */
     close(): Promise<void>;
 }
 export interface ControllerOptions {
     workspaceRoot: string;
     providers: RuntimeProviders;
-    runtime?: Runtime;
 }
-/** The state behind the screen: a session, the works it starts, and the lines to show. */
+/**
+ * The state behind the screen: a session, the works it starts, and the lines to show. The
+ * conversation reaches the runtime only as an MCP client of the workspace's own server, the way
+ * any other agent does; the records are read directly for the closing lines.
+ */
 export declare function createController(options: ControllerOptions): Promise<Controller>;
-/** Lines that close a work in the screen: the CLI's closing lines without the summary, which the clerk relays. */
-export declare function workReport(runtime: Runtime, workId: WorkId): Promise<string[]>;
+/** Lines that close a work in the screen: the CLI's closing lines without the summary, which the agent relays. */
+export declare function workReport(store: WorkStore, workId: WorkId): Promise<string[]>;
 export { statusLabel };

package/dist/tui/controller.js

@@ -1,15 +1,20 @@
-import { createSession } from "@openshain/agent";
-import { createRuntime, } from "@openshain/core";
-import { progressLine, report } from "../commands/run.js";
+import { connectInMemory, createSession, } from "@openshain/agent";
+import { loadConfig, OpenshainError, WorkStore, } from "@openshain/core";
+import { createMcpServer } from "@openshain/mcp";
 import { toolsList } from "../commands/tools.js";
-import { workList, workResume, workShow } from "../commands/work.js";
-import { plain } from "../format.js";
+import { workList, workShow } from "../commands/work.js";
+import { describeInput, plain } from "../format.js";
 import { statusLabel } from "../labels.js";
+import { previewCall } from "../preview.js";
+import { progressLine, report } from "../report.js";
 import { LOGO_ROWS, VERSION } from "./banner.js";
 const HELP = [
     "/work list         Work の一覧",
     "/work show <id>    Work の詳細",
-    "/work resume <id>  止まった Work を続ける",
+    "/work resume <id>  止まった Work を候補にする。次の依頼がそれに沿えば続ける",
+    "/approvals         承認待ちの一覧",
+    "/approve <id>      承認して実行する。/reject <id> [理由] で拒否する",
+    "/review <id> approve|reject  資格者の判断を記録する。名前と本文を順に聞く",
     "/tools             使える Tool",
     "/quit              終わる",
     "↑ ↓                前に送った行を入力欄に呼び戻す。いちばん下は新しい入力",
@@ -17,21 +22,51 @@ const HELP = [
     "ホイール、PageUp/PageDown  会話を遡る。送ると最新に戻る",
     "Ctrl-C             動いている Work を止める。質問待ちなら質問を取り下げる。何も動いていなければ終わる",
 ];
+/** The choices the screen offers for a held call, in the order they are shown. */
+const APPROVAL_CHOICES = [
+    { key: "approve", label: "はい。実行する" },
+    { key: "always", label: "はい。この会話では同じ規則の呼び出しを常に承認する" },
+    { key: "reject", label: "いいえ。実行しない" },
+    { key: "reject_with_reason", label: "いいえ。理由を伝えて実行しない" },
+];
 /** What the session's model hears when the person stops a work that waits for their answer. */
 const QUESTION_WITHDRAWN = "the person stopped the work while it waited for their answer; the question is still pending and the work can be resumed";
-/** The state behind the screen: a session, the works it starts, and the lines to show. */
+/** What the loop hears when the person leaves a held call undecided. */
+const APPROVAL_WITHDRAWN = "the person left the approval undecided";
+/**
+ * The state behind the screen: a session, the works it starts, and the lines to show. The
+ * conversation reaches the runtime only as an MCP client of the workspace's own server, the way
+ * any other agent does; the records are read directly for the closing lines.
+ */
 export async function createController(options) {
-    const runtime = options.runtime ??
-        (await createRuntime({ workspaceRoot: options.workspaceRoot, providers: options.providers }));
+    const { workspaceRoot, providers } = options;
+    const config = await loadConfig(workspaceRoot, { modelProviders: Object.keys(providers.models) });
+    if (!config.model) {
+        throw new OpenshainError("config", "対話にはモデルが要ります。openshain.yaml に model を書いてください。Claude Code や Codex から使うだけなら要りません。");
+    }
+    const modelFactory = Object.hasOwn(providers.models, config.model.provider)
+        ? providers.models[config.model.provider]
+        : undefined;
+    if (!modelFactory) {
+        throw new OpenshainError("config", `unknown model provider "${config.model.provider}"`);
+    }
+    const model = modelFactory(config.model);
+    if (!model.describe().capabilities.tools) {
+        throw new OpenshainError("config", `model ${config.model.provider}/${config.model.model} cannot call tools; openshain needs a model with tool support`);
+    }
+    const server = await createMcpServer({ workspaceRoot, tools: providers.tools });
+    const client = await connectInMemory(server);
+    const store = new WorkStore(workspaceRoot);
     const listeners = new Set();
     let nextId = 1;
     const state = {
         entries: [],
         busy: false,
         closed: false,
+        queued: [],
         status: {
-            company: runtime.config.company.name,
-            model: `${runtime.config.model.provider}/${runtime.config.model.model}`,
+            company: config.company.name,
+            model: `${config.model.provider}/${config.model.model}`,
             usage: { modelCalls: 0, inputTokens: 0, outputTokens: 0 },
         },
     };
@@ -60,12 +95,20 @@ export async function createController(options) {
         notify();
     };
     let pending;
+    let deciding;
     let aborter;
     let running;
     let closing;
-    /** The child work of the current turn while it is unfinished. */
-    let lastWorkId;
     const names = new Map();
+    /** Asks the person for one line and waits for it. The next line they type is the answer. */
+    const askLine = (question) => {
+        state.question = question;
+        push("question", question);
+        notify();
+        return new Promise((resolve, reject) => {
+            pending = { resolve, reject };
+        });
+    };
     const ask = (workId, question) => {
         state.question = question;
         push("question", `${question}(${workId})`);
@@ -73,6 +116,51 @@ export async function createController(options) {
             pending = { resolve, reject };
         });
     };
+    /** Shows a held call and waits for the person to pick one of the choices. */
+    const askApproval = async (approval) => {
+        const preview = await previewCall(workspaceRoot, {
+            name: approval.name,
+            input: approval.input,
+        }).catch((err) => [{ kind: "note", text: message(err) }]);
+        const title = `${approval.name} ${describeInput(approval.input)}`.trimEnd();
+        state.approval = {
+            approvalId: approval.approvalId,
+            title,
+            ruleId: approval.ruleId,
+            preview,
+            choices: APPROVAL_CHOICES,
+            at: 0,
+        };
+        push("question", `承認が要ります: ${title}`);
+        for (const line of preview) {
+            push("progress", `${line.kind === "added" ? "+ " : line.kind === "removed" ? "- " : "  "}${line.text}`);
+        }
+        return new Promise((resolve, reject) => {
+            deciding = { resolve, reject };
+        });
+    };
+    /** Settles the approval being shown, or takes it back when there is no choice. */
+    const settleApproval = (choice, comment) => {
+        const waiting = deciding;
+        deciding = undefined;
+        if (state.reason !== undefined) {
+            delete state.reason;
+            notify();
+        }
+        if (state.approval !== undefined) {
+            const decided = choice ? APPROVAL_CHOICES.find((c) => c.key === choice)?.label : undefined;
+            delete state.approval;
+            if (decided)
+                push("line", `> ${decided}`);
+            notify();
+        }
+        if (!waiting)
+            return;
+        if (choice === undefined)
+            waiting.reject(new Error(APPROVAL_WITHDRAWN));
+        else
+            waiting.resolve({ choice, ...(comment !== undefined && comment !== "" && { comment }) });
+    };
     /** Answers the pending question, or takes it back when there is no answer. */
     const settleQuestion = (answer) => {
         const waiting = pending;
@@ -90,66 +178,95 @@ export async function createController(options) {
     };
     /** The lines the CLI prints when a work ends, shown among the progress lines. */
     const closingLines = async (workId) => {
-        for (const line of await workReport(runtime, workId))
+        for (const line of await workReport(store, workId))
             push("progress", line.trimStart());
     };
-    const onWorkEvent = (workId, event) => {
-        lastWorkId = workId;
-        if (event.type === "work.status_changed") {
-            state.status.work = {
-                id: workId,
-                status: event.payload.to,
-            };
-        }
-        else if (event.type === "work.completed" || event.type === "work.failed") {
-            lastWorkId = undefined;
-            state.status.work = {
-                id: workId,
-                status: event.type === "work.completed" ? "completed" : "failed",
-            };
-            return closingLines(workId);
-        }
-        const line = progressLine(event, names);
-        if (line)
-            push("progress", line);
-        else
-            notify();
-    };
-    const session = await createSession(runtime, {
-        onEvent: (event) => {
-            if (event.type === "usage.recorded") {
-                const { payload } = event;
-                if (payload.kind === "model_inference") {
-                    state.status.usage.modelCalls += 1;
-                    state.status.usage.inputTokens += payload.usage.inputTokens;
-                    state.status.usage.outputTokens += payload.usage.outputTokens;
-                    notify();
+    let sessionId;
+    /** Summaries of the works completed in this turn, until the agent reports them itself. */
+    let unreported = [];
+    const session = await createSession(client, {
+        model,
+        config,
+        onEvent: (workId, event) => {
+            if (workId === sessionId) {
+                if (event.type === "usage.recorded") {
+                    const { payload } = event;
+                    if (payload.kind === "model_inference") {
+                        state.status.usage.modelCalls += 1;
+                        state.status.usage.inputTokens += payload.usage.inputTokens;
+                        state.status.usage.outputTokens += payload.usage.outputTokens;
+                        notify();
+                    }
                 }
+                return;
+            }
+            if (event.type === "work.status_changed") {
+                state.status.work = {
+                    id: workId,
+                    status: event.payload.to,
+                };
+                notify();
+                return;
+            }
+            if (event.type === "work.completed" || event.type === "work.failed") {
+                state.status.work = {
+                    id: workId,
+                    status: event.type === "work.completed" ? "completed" : "failed",
+                };
+                if (event.type === "work.completed") {
+                    // Held, not shown: the agent is the one who tells the person what happened. It is
+                    // shown only if the turn ends without the agent saying anything (see submit).
+                    const { summary } = event.payload;
+                    if (summary.trim() !== "")
+                        unreported.push(summary.trim());
+                }
+                return closingLines(workId);
             }
+            // The work_* calls are the loop's own bookkeeping; the closing lines already say the work ended.
+            if (event.type === "tool.called" &&
+                event.payload.name.startsWith("work_")) {
+                names.set(event.payload.callId, event.payload.name);
+                return;
+            }
+            const line = progressLine(event, names);
+            if (line)
+                push("progress", line);
+            else
+                notify();
         },
-        onWorkEvent,
         onInput: ask,
+        onApproval: askApproval,
     });
+    sessionId = session.id;
     state.status.agentName = session.agentName;
     for (const row of LOGO_ROWS)
         push("logo", row);
     push("banner", `openshain ${VERSION}`);
-    push("banner", runtime.workspaceRoot);
+    push("banner", workspaceRoot);
     const stopped = (workId) => workId
-        ? `止めました。${workId} は途中のまま残っています。/work resume ${workId} で続けられます。`
+        ? `止めました。${workId} は途中のまま残っています。/work resume ${workId} で続けられるようにします。`
         : "止めました。";
     const explain = (result) => {
         switch (result.stopped) {
             case "turn_limit":
-                return "社員エージェントが 1 回の返答でできる回数を超えたので、ここで止めました。続きを依頼できます。";
+                return "社員エージェントが 1 回の返答でできる回数を超えたので、ここで止めました。続きは改めて依頼してください。";
             case "aborted":
-                return stopped(lastWorkId);
+                return stopped(result.work);
             case "max_tokens":
                 return "返答が長さの上限で切れました。";
             case "refusal":
                 return "社員エージェントが続けられないと言っています。";
             case "model_error":
                 return `model の呼び出しに失敗しました。${result.detail ?? ""}`.trim();
+            case "approval": {
+                const a = result.approval;
+                if (!a)
+                    return "承認が要ります。/approvals で確かめてください。";
+                if (a.kind === "review") {
+                    return `${a.reviewer?.role ?? "資格者"}の判断が要ります: ${a.name} ${describeInput(a.input)}(${a.approvalId})。Review Package は work/${a.workId}/review/ にあります。返答が届いたら /review ${a.approvalId} approve か /review ${a.approvalId} reject で記録します。`;
+                }
+                return `承認が要ります: ${a.name} ${describeInput(a.input)}(${a.approvalId})。/approve ${a.approvalId} で実行、/reject ${a.approvalId} で拒否します。`;
+            }
             default:
                 return undefined;
         }
@@ -172,6 +289,15 @@ export async function createController(options) {
             notify();
         }
     };
+    /** Sends what the person typed while the agent was working, oldest first. */
+    const drainQueue = async () => {
+        while (state.queued.length > 0 && !closing) {
+            const [next, ...rest] = state.queued;
+            state.queued = rest;
+            notify();
+            await self.submit(next);
+        }
+    };
     const capture = async (fn) => {
         try {
             await fn((line) => push("line", line));
@@ -198,24 +324,72 @@ export async function createController(options) {
         else if (name === "work" && sub === "show" && id)
             await capture((write) => workShow({ workspaceRoot: options.workspaceRoot, id, write }));
         else if (name === "work" && sub === "resume" && id) {
-            await stoppable(async (signal) => {
-                try {
-                    await workResume({
-                        workspaceRoot: options.workspaceRoot,
-                        providers: options.providers,
-                        id,
-                        signal,
-                        write: (text) => push("line", text),
-                        ask: (q) => ask(id, q),
-                    });
+            try {
+                const work = await session.select(id);
+                push("notice", `${work.id}(${statusLabel(work.status)}、${work.objective})を候補にしました。次の依頼がこの Work に沿えば続けます。`);
+            }
+            catch (err) {
+                push("notice", message(err));
+            }
+        }
+        else if (name === "approvals") {
+            try {
+                const held = await session.approvals();
+                if (held.length === 0)
+                    push("line", "承認待ちはありません。");
+                for (const a of held) {
+                    push("line", `${a.approvalId}  ${a.name} ${describeInput(a.input)}  (${a.workId})`);
                 }
-                catch (err) {
-                    if (!signal.aborted)
-                        push("notice", message(err));
+            }
+            catch (err) {
+                push("notice", message(err));
+            }
+        }
+        else if ((name === "approve" || name === "reject") && sub) {
+            try {
+                const comment = args.slice(1).join(" ");
+                const { text } = await session.decide(sub, name, comment || undefined);
+                push("line", text);
+            }
+            catch (err) {
+                push("notice", message(err));
+            }
+        }
+        else if (name === "approve" || name === "reject") {
+            push("notice", `/${name} には承認の id が要ります。/approvals で確かめてください。`);
+        }
+        else if (name === "review" && sub && (args[1] === "approve" || args[1] === "reject")) {
+            const decision = args[1];
+            try {
+                // The rule already says which role has to decide; the person only says who they are.
+                const held = (await session.approvals()).find((a) => a.approvalId === sub);
+                if (!held)
+                    throw new Error(`${sub} は承認待ちにありません。/approvals で確かめてください。`);
+                if (held.kind !== "review") {
+                    throw new Error(`${sub} は人の承認待ちです。/approve か /reject で決めます。`);
                 }
-                if (signal.aborted)
-                    push("notice", stopped(id));
-            });
+                const role = held.reviewer?.role ?? "reviewer";
+                const who = await askLine(`${role} の名前と資格(例: 田中 太郎 / 税理士)。会社の申告として記録します`);
+                const [reviewerName, qualification] = who.split("/").map((part) => part.trim());
+                const interpretation = await askLine(decision === "approve" ? "判断の本文(そのまま記録します)" : "認めない理由");
+                const { text } = await session.review({
+                    approvalId: sub,
+                    decision,
+                    reviewer: {
+                        name: reviewerName || who,
+                        role,
+                        ...(qualification && { qualification }),
+                    },
+                    interpretation,
+                });
+                push("line", text);
+            }
+            catch (err) {
+                push("notice", message(err));
+            }
+        }
+        else if (name === "review") {
+            push("notice", "/review <id> approve か /review <id> reject の形です。");
         }
         else if (name === "resume") {
             push("notice", "セッションの再開はまだありません。止まった Work を続けるなら /work resume <id> です。");
@@ -228,14 +402,23 @@ export async function createController(options) {
         closing ??= (async () => {
             aborter?.abort();
             settleQuestion();
+            settleApproval();
             await running;
-            await session.close();
-            state.closed = true;
-            notify();
+            try {
+                await session.close();
+            }
+            catch (err) {
+                push("notice", `会話の記録を閉じられませんでした。${message(err)}`);
+            }
+            finally {
+                await client.close().catch(() => undefined);
+                state.closed = true;
+                notify();
+            }
         })();
         return closing;
     }
-    return {
+    const self = {
         sessionId: session.id,
         state: () => state,
         subscribe(listener) {
@@ -246,6 +429,15 @@ export async function createController(options) {
             const text = line.trim();
             if (text === "" || closing)
                 return;
+            if (state.approval) {
+                push("notice", "承認を先に決めてください。数字か ↑↓ と Enter で選びます。");
+                return;
+            }
+            if (state.reason !== undefined) {
+                push("user", text);
+                settleApproval("reject", text);
+                return;
+            }
             if (pending) {
                 push("user", text);
                 // Everything typed answers the question, except leaving: that takes the question back.
@@ -256,7 +448,10 @@ export async function createController(options) {
                 return;
             }
             if (state.busy) {
-                push("notice", "いま動いています。止めるなら Ctrl-C。");
+                // Typing while the agent works is not a mistake: the line waits its turn.
+                state.queued = [...state.queued, text];
+                push("notice", `順番待ち(${state.queued.length} 件): ${text}`);
+                notify();
                 return;
             }
             if (text.startsWith("/")) {
@@ -265,11 +460,16 @@ export async function createController(options) {
                 return;
             }
             push("user", text);
+            unreported = [];
             await stoppable(async (signal) => {
                 try {
                     const result = await session.turn(text, { signal });
-                    if (result.reply)
-                        push("assistant", result.reply);
+                    // What the work recorded is the agent's own writing, so it stands in when the turn
+                    // ends with nothing said. Without this the person is left with a work that finished
+                    // and no answer, which is what a model that skips its summary leaves behind.
+                    const reply = result.reply.trim() === "" ? unreported.join("\n\n") : result.reply;
+                    if (reply)
+                        push("assistant", reply);
                     const note = explain(result);
                     if (note)
                         push("notice", note);
@@ -278,21 +478,50 @@ export async function createController(options) {
                     push("notice", message(err));
                 }
             });
+            await drainQueue();
         },
         interrupt() {
             if (!aborter)
                 return false;
             aborter.abort();
             settleQuestion();
+            settleApproval();
             return true;
         },
+        moveApproval(delta) {
+            const approval = state.approval;
+            if (!approval)
+                return;
+            const count = approval.choices.length;
+            state.approval = { ...approval, at: (approval.at + delta + count) % count };
+            notify();
+        },
+        decideApproval(choice) {
+            const approval = state.approval;
+            if (!approval)
+                return;
+            const picked = choice ?? approval.choices[approval.at]?.key ?? "reject";
+            if (picked === "reject_with_reason") {
+                // The palette closes and the input box takes the reason; the loop still waits.
+                const shown = APPROVAL_CHOICES.find((c) => c.key === picked)?.label;
+                delete state.approval;
+                state.reason = "実行しない理由(社員エージェントに伝わります)";
+                if (shown)
+                    push("line", `> ${shown}`);
+                push("question", state.reason);
+                notify();
+                return;
+            }
+            settleApproval(picked);
+        },
         close,
     };
+    return self;
 }
-/** Lines that close a work in the screen: the CLI's closing lines without the summary, which the clerk relays. */
-export async function workReport(runtime, workId) {
-    const work = await runtime.works.get(workId);
-    const events = await runtime.works.events(workId);
+/** Lines that close a work in the screen: the CLI's closing lines without the summary, which the agent relays. */
+export async function workReport(store, workId) {
+    const work = await store.get(workId);
+    const events = await store.events(workId);
     const lines = report(work, events);
     return work.status === "completed" ? ["完了。", ...lines.slice(1)] : lines;
 }

package/dist/tui/index.js

@@ -40,6 +40,6 @@ export async function startTui(options) {
     finally {
         leave();
     }
-    console.log(`会話を終えました。記録は openshain work show ${controller.sessionId} で読めます。`);
+    console.log(`会話を終えました。記録は openshain work show ${controller.sessionId} で参照します。`);
     return 0;
 }

package/dist/tui/lines.d.ts

@@ -1,12 +1,14 @@
-import { type Segment } from "./banner.ts";
 import type { Entry, EntryKind } from "./controller.ts";
+import { type Span } from "./markdown.ts";
 export interface ScreenLine {
     kind: EntryKind | "blank";
+    /** The row as plain characters, marker included. */
     text: string;
-    /** Colored pieces of a logo row; the other rows are one color. */
-    segments?: Segment[];
+    /** The row as styled pieces: a logo row, or a reply the screen drew from its markdown. */
+    spans?: Span[];
 }
 /** Breaks text into lines no wider than `width` display columns, counting East Asian wide characters as two. */
 export declare function wrapText(text: string, width: number): string[];
+export declare function rowsFor(entry: Entry, width: number): Span[][];
 /** The rows the screen shows for the entries, wrapped to the width, with markers and blank rows between blocks. */
 export declare function screenLines(entries: readonly Entry[], width: number): ScreenLine[];