@linkshell/host 0.4.6 → 0.4.8

package/dist/host/src/drivers/codex/driver.js

@@ -1,8 +1,9 @@
 import { statSync } from "node:fs";
-import { ABANDON, RpcError } from "@linkshell/wire";
+import { codexPreview } from "./computer-preview.js";
+import { ABANDON, RpcError, sessionGoalSchema } from "@linkshell/wire";
 import { parseCodexLoginStatus, runStatusCommand } from "../auth.js";
 import { CodexAppServer, CodexSharedServer, detectCodex, sharedServerSocket } from "./app-server.js";
-import { APPROVAL_METHODS, QUESTION_METHODS, mapApprovalRequest, mapQuestionRequest, mapNotification, threadStateOf, threadToDiscovered, spawnedThreads, threadToHistory, toCodexInput, toolStart, turnUnderWay, } from "./mapper.js";
+import { APPROVAL_METHODS, QUESTION_METHODS, mapApprovalRequest, mapQuestionRequest, mapNotification, threadStateOf, threadToDiscovered, spawnedThreads, subagentHistory, threadToHistory, toCodexInput, toolStart, turnUnderWay, } from "./mapper.js";
 import { nestHistory, nestUnder } from "../nesting.js";
 import { configOptions, effective, settingsFrom, turnOverrides } from "./settings.js";
 import { COMMANDS, INIT_PROMPT, commandOf } from "./commands.js";
@@ -79,6 +80,9 @@ export class CodexDriver {
     /** Each thread's working directory: where its skills are looked up. */
     cwds = new Map();
     skills = new Map();
+    goalAvailable = new Set();
+    goalRevision = new Map();
+    skillsRevision = 0;
     models;
     restartTimer;
     restartDelay;
@@ -93,6 +97,11 @@ export class CodexDriver {
     /** Notifications for a thread being joined, held until its history has been read. */
     joining = new Map();
     /** Threads a device has open. */
+    taskProcesses = new Map();
+    taskPolls = new Map();
+    taskSyncs = new Map();
+    stoppingTasks = new Set();
+    taskRevisions = new Map();
     watching = new Set();
     /** Threads another client of this host's app-server opened (`linkshell codex`): followed for as long as the host runs. */
     kept = new Set();
@@ -134,6 +143,9 @@ export class CodexDriver {
         return parseCodexLoginStatus(await runStatusCommand(this.options.command ?? "codex", ["login", "status"], this.options.env));
     }
     async stop() {
+        for (const timer of this.taskPolls.values())
+            clearTimeout(timer);
+        this.taskPolls.clear();
         this.stopped = true;
         if (this.restartTimer)
             clearTimeout(this.restartTimer);
@@ -226,6 +238,7 @@ export class CodexDriver {
             // rollout yet, so thread/resume would fail. Nothing to import either.
             void this.announceConfig(nativeId);
             void this.announceCommands(nativeId);
+            void this.announceGoal(nativeId);
             return [];
         }
         let joined;
@@ -250,6 +263,7 @@ export class CodexDriver {
         this.reportHeld(nativeId, false);
         void this.announceConfig(nativeId);
         void this.announceCommands(nativeId);
+        void this.announceGoal(nativeId);
         if (this.waiting.has(nativeId))
             void this.syncWaiting(nativeId);
         this.considerRelease(nativeId);
@@ -317,6 +331,7 @@ export class CodexDriver {
     }
     /** Says where the joined thread stands, then lets through what arrived while it was being read. */
     goLive(threadId, { thread, underWay }) {
+        void this.syncTasks(threadId);
         const state = this.stateOf(threadId);
         const active = thread.turns?.find((turn) => turn.status === "inProgress");
         state.activeTurnId = active?.id;
@@ -370,6 +385,8 @@ export class CodexDriver {
             this.cwds.set(threadId, thread.cwd);
         this.host?.update(this.id, threadId, { sessionUpdate: "ls_status", state: running ? "running" : "idle" });
         this.reportHeld(threadId, true);
+        void this.announceCommands(threadId);
+        void this.announceGoal(threadId);
         // What was queued for it before this host last started is still waiting.
         void this.syncWaiting(threadId);
         this.considerRelease(threadId);
@@ -380,10 +397,19 @@ export class CodexDriver {
         const watch = this.observed.get(threadId);
         if (!watch || watch.reading)
             return;
+        if (!watch.goalReading && this.goalAvailable.has(threadId) && Date.now() - (watch.goalCheckedAt ?? 0) >= 5000) {
+            watch.goalCheckedAt = Date.now();
+            watch.goalReading = true;
+            // Goal changes live in SQLite and need not change the rollout file.
+            void this.goal(threadId, { action: "get" }).catch(() => { }).finally(() => { watch.goalReading = false; });
+        }
         if (this.waiting.has(threadId))
             void this.syncWaiting(threadId);
         const stamp = watch.path ? fileStamp(watch.path) : undefined;
-        if (stamp !== undefined && stamp === watch.stamp)
+        // A parent waiting for its agents may not write anything while their own
+        // rollout files keep growing. Each of those files can invalidate the read.
+        const childrenChanged = [...this.children.values()].some((child) => child.threadId === threadId && (!child.path || child.stamp === undefined || fileStamp(child.path) !== child.stamp));
+        if (stamp !== undefined && stamp === watch.stamp && !childrenChanged)
             return;
         watch.reading = true;
         try {
@@ -462,6 +488,7 @@ export class CodexDriver {
                 this.reportHeld(threadId, false);
                 void this.announceConfig(threadId);
                 void this.announceCommands(threadId);
+                void this.announceGoal(threadId);
                 // What still waits in Codex's queue is started by this host's app-server now.
                 void this.syncWaiting(threadId);
             })().finally(() => this.takingUp.delete(threadId));
@@ -640,6 +667,7 @@ export class CodexDriver {
     watched(nativeId, open) {
         if (open) {
             this.watching.add(nativeId);
+            void this.syncTasks(nativeId);
             this.cancelRelease(nativeId);
         }
         else {
@@ -647,6 +675,84 @@ export class CodexDriver {
             this.considerRelease(nativeId);
         }
     }
+    publishTask(threadId, task) {
+        const { lastSeq: _, ...record } = task;
+        this.host?.update(this.id, threadId, { sessionUpdate: "ls_task", task: record });
+    }
+    loseTasks(threadId) {
+        clearTimeout(this.taskPolls.get(threadId));
+        this.taskPolls.delete(threadId);
+        this.taskProcesses.delete(threadId);
+        this.taskRevisions.set(threadId, (this.taskRevisions.get(threadId) ?? 0) + 1);
+        for (const task of this.host?.tasks(this.id, threadId) ?? []) {
+            if (task.state === "running")
+                this.publishTask(threadId, { ...task, state: "unknown", endedAt: Date.now(), canStop: false });
+        }
+    }
+    syncTasks(threadId) {
+        const pending = this.taskSyncs.get(threadId);
+        if (pending)
+            return pending;
+        if (!this.attached.has(threadId) || this.observed.has(threadId))
+            return Promise.resolve();
+        const sync = this.readTasks(threadId).catch(() => { }).finally(() => {
+            this.taskSyncs.delete(threadId);
+            clearTimeout(this.taskPolls.get(threadId));
+            this.taskPolls.delete(threadId);
+            if (this.attached.has(threadId) && this.watching.has(threadId) && this.host?.tasks(this.id, threadId).some((task) => task.state === "running")) {
+                const timer = setTimeout(() => void this.syncTasks(threadId), 5000);
+                timer.unref?.();
+                this.taskPolls.set(threadId, timer);
+            }
+        });
+        this.taskSyncs.set(threadId, sync);
+        return sync;
+    }
+    async readTasks(threadId) {
+        const revision = this.taskRevisions.get(threadId) ?? 0;
+        const entries = [];
+        let cursor;
+        do {
+            const page = await this.rpcFor(threadId, "thread/backgroundTerminals/list", { threadId, limit: 100, ...(cursor ? { cursor } : {}) });
+            entries.push(...page.data);
+            cursor = page.nextCursor ?? undefined;
+        } while (cursor);
+        if (!this.attached.has(threadId) || revision !== (this.taskRevisions.get(threadId) ?? 0))
+            return;
+        const previous = new Map((this.host?.tasks(this.id, threadId) ?? []).map((task) => [task.id, task]));
+        const processes = new Map();
+        for (const entry of entries) {
+            processes.set(entry.itemId, entry.processId);
+            const old = previous.get(entry.itemId);
+            if (old?.state === "running")
+                continue;
+            this.publishTask(threadId, { id: entry.itemId, kind: "shell", toolCallId: entry.itemId, title: this.toolTitles.get(entry.itemId) ?? entry.command, command: entry.command, state: "running", startedAt: old?.startedAt ?? Date.now(), output: true, canStop: true });
+        }
+        this.taskProcesses.set(threadId, processes);
+        for (const task of previous.values()) {
+            if (task.state === "running" && !processes.has(task.id))
+                this.publishTask(threadId, { ...task, state: "unknown", endedAt: Date.now(), canStop: false });
+        }
+    }
+    async stopTask(nativeId, taskId) {
+        await this.syncTasks(nativeId);
+        const processId = this.taskProcesses.get(nativeId)?.get(taskId);
+        if (!processId)
+            throw RpcError.app("not_found", "这个后台任务已经不在运行列表里");
+        const key = `${nativeId}:${taskId}`;
+        this.stoppingTasks.add(key);
+        try {
+            const result = await this.rpcFor(nativeId, "thread/backgroundTerminals/terminate", { threadId: nativeId, processId });
+            if (!result.terminated)
+                throw RpcError.app("busy", "没能停止这个后台任务");
+            const task = this.host?.tasks(this.id, nativeId).find((task) => task.id === taskId);
+            if (task?.state === "running")
+                this.publishTask(nativeId, { ...task, state: "stopped", endedAt: Date.now(), canStop: false });
+        }
+        finally {
+            this.stoppingTasks.delete(key);
+        }
+    }
     cancelRelease(threadId) {
         clearTimeout(this.releases.get(threadId));
         this.releases.delete(threadId);
@@ -707,6 +813,17 @@ export class CodexDriver {
     }
     /** Nests each sub-agent's own history right after the call that spawned it. */
     async withSubAgents(threadId, thread, history) {
+        // Restore the last surface across idle turns and history windows.
+        outer: for (const turn of [...(thread.turns ?? [])].reverse()) {
+            for (const item of [...turn.items].reverse()) {
+                const stamp = turn.completedAt ?? turn.startedAt ?? thread.updatedAt;
+                const frame = codexPreview(item, stamp < 1e12 ? stamp * 1000 : stamp);
+                if (frame) {
+                    this.host?.preview?.(this.id, threadId, frame);
+                    break outer;
+                }
+            }
+        }
         const spawns = new Map();
         for (const turn of thread.turns ?? []) {
             for (const item of turn.items) {
@@ -715,17 +832,31 @@ export class CodexDriver {
                 if (!callId || ids.length === 0)
                     continue;
                 spawns.set(callId, ids);
-                for (const child of ids)
-                    this.children.set(child, { threadId, toolCallId: callId });
+                for (const child of ids) {
+                    this.subThreads.add(child);
+                    this.children.set(child, { ...this.children.get(child), threadId, toolCallId: callId });
+                }
             }
         }
         if (spawns.size === 0)
             return history;
         const nested = new Map();
         await Promise.all([...spawns].map(async ([callId, ids]) => {
-            const parts = await Promise.all(ids.map((child) => this.rpcFor(threadId, "thread/read", { threadId: child, includeTurns: true })
-                .then((result) => nestHistory(threadToHistory(result.thread), callId))
-                .catch(() => [])));
+            const parts = await Promise.all(ids.map(async (child) => {
+                const known = this.children.get(child);
+                const stamp = known.path ? fileStamp(known.path) : undefined;
+                try {
+                    const result = await this.rpcFor(threadId, "thread/read", { threadId: child, includeTurns: true });
+                    known.path = result.thread.path ?? undefined;
+                    known.stamp = stamp;
+                    return nestHistory(subagentHistory(result.thread), callId);
+                }
+                catch {
+                    // A just-started child may not have written its rollout yet.
+                    known.stamp = undefined;
+                    return [];
+                }
+            }));
             nested.set(callId, parts.flat());
         }));
         return history.flatMap((item) => {
@@ -735,6 +866,9 @@ export class CodexDriver {
         });
     }
     async detach(nativeId) {
+        clearTimeout(this.taskPolls.get(nativeId));
+        this.taskPolls.delete(nativeId);
+        this.taskProcesses.delete(nativeId);
         this.cancelRelease(nativeId);
         this.stopObserving(nativeId);
         if (!this.attached.delete(nativeId))
@@ -757,6 +891,61 @@ export class CodexDriver {
      */
     async runCommand(nativeId, command, clientMessageId) {
         const echo = () => this.host?.update(this.id, nativeId, { sessionUpdate: "user_message_chunk", messageId: `local-${clientMessageId}`, content: { type: "text", text: command.text } }, `command:${clientMessageId}`);
+        if (command.name === "goal") {
+            const args = command.args;
+            const change = !args ? { action: "get" }
+                : args === "pause" || args === "resume" || args === "clear" ? { action: args }
+                    : { action: "set", objective: args.replace(/^edit\s+/, "") };
+            if (args === "edit")
+                throw RpcError.app("invalid_params", "请在 /goal edit 后写上新的目标，或打开目标面板编辑");
+            const goal = await this.goal(nativeId, change);
+            echo();
+            this.host?.update(this.id, nativeId, { sessionUpdate: "ls_notice", level: "info", title: goal ? `目标：${goal.objective}` : "当前没有目标" });
+            return "started";
+        }
+        if (command.name === "reload-skills") {
+            this.skillsRevision++;
+            this.skills.delete(this.cwds.get(nativeId) ?? "");
+            await this.loadSkills(this.cwds.get(nativeId), true);
+            await this.announceCommands(nativeId);
+            echo();
+            this.host?.update(this.id, nativeId, { sessionUpdate: "ls_notice", level: "info", title: "已刷新可用技能" });
+            return "started";
+        }
+        if (["status", "mcp", "apps", "ps", "stop"].includes(command.name)) {
+            if (command.args)
+                throw RpcError.app("invalid_params", `/${command.name} 暂不接受参数`);
+            const lines = [];
+            if (command.name === "status") {
+                const { thread } = await this.rpcFor(nativeId, "thread/read", { threadId: nativeId, includeTurns: false });
+                const current = effective(this.settings.get(nativeId) ?? {}, this.overrides.get(nativeId) ?? {}, await this.loadModels());
+                const running = this.observed.get(nativeId)?.running ?? Boolean(this.stateOf(nativeId).activeTurnId);
+                lines.push(`目录：${thread.cwd}`, `模型：${current.model ?? "默认"}`, `推理强度：${current.effort ?? "默认"}`, `状态：${running ? "运行中" : "空闲"}`);
+            }
+            else if (command.name === "stop") {
+                await this.rpcFor(nativeId, "thread/backgroundTerminals/clean", { threadId: nativeId });
+                lines.push("已停止当前会话的后台终端");
+            }
+            else {
+                const method = command.name === "mcp" ? "mcpServerStatus/list" : command.name === "apps" ? "app/list" : "thread/backgroundTerminals/list";
+                let cursor;
+                const seen = new Set();
+                do {
+                    const page = await this.rpcFor(nativeId, method, { threadId: nativeId, limit: 100, ...(cursor ? { cursor } : {}) });
+                    for (const entry of page.data) {
+                        lines.push(command.name === "ps" ? `${entry.processId ?? ""} · ${entry.command ?? "后台终端"}` : command.name === "mcp" ? `${entry.name ?? "MCP"} · ${Object.keys(entry.tools ?? {}).length} 个工具 · ${entry.authStatus ?? ""}` : `${entry.name ?? "应用"} · ${entry.isEnabled ? "已启用" : "未启用"}`);
+                    }
+                    cursor = page.nextCursor ?? undefined;
+                    if (cursor && seen.has(cursor))
+                        throw RpcError.app("invalid_params", "Agent 返回了重复的分页游标，请重试");
+                    if (cursor)
+                        seen.add(cursor);
+                } while (cursor);
+            }
+            echo();
+            this.host?.update(this.id, nativeId, { sessionUpdate: "ls_notice", level: "info", title: `/${command.name}`, detail: lines.join("\n") || "当前没有记录" });
+            return "started";
+        }
         if (command.name === "compact" || command.name === "review") {
             // Not something a queue can carry: they run in the app-server that has the thread.
             if (this.observed.has(nativeId))
@@ -783,7 +972,7 @@ export class CodexDriver {
         }
         const skill = (await this.loadSkills(this.cwds.get(nativeId))).find((entry) => entry.name === command.name);
         if (!skill)
-            return undefined;
+            throw RpcError.app("not_supported", `当前 Codex 未提供 /${command.name}。请从命令面板选择可用命令。`);
         // The way the TUI sends a skill: the skill itself, and `$name` in the text.
         return this.send(nativeId, [
             { type: "skill", name: skill.name, path: skill.path },
@@ -820,6 +1009,41 @@ export class CodexDriver {
         });
         return "started";
     }
+    async goal(nativeId, change) {
+        if (this.observed.has(nativeId) && change.action !== "get")
+            throw this.refused(nativeId, "会话开在电脑的另一个 Codex 里 · 暂时只能查看目标", HELD_COMMAND);
+        const method = change.action === "get" ? "thread/goal/get" : change.action === "clear" ? "thread/goal/clear" : "thread/goal/set";
+        let status = "active";
+        if (change.action === "set") {
+            const current = await this.rpcFor(nativeId, "thread/goal/get", { threadId: nativeId });
+            // Editing a paused goal must not silently restart work. This matches the
+            // native editor; finished or exhausted goals start afresh when edited.
+            if (current.goal && ["paused", "blocked", "usageLimited"].includes(current.goal.status))
+                status = current.goal.status;
+        }
+        const params = change.action === "set"
+            ? { threadId: nativeId, objective: change.objective, status, ...(change.tokenBudget === undefined ? {} : { tokenBudget: change.tokenBudget }) }
+            : { threadId: nativeId, ...(change.action === "pause" ? { status: "paused" } : change.action === "resume" ? { status: "active" } : {}) };
+        const revision = this.goalRevision.get(nativeId) ?? 0;
+        const result = await this.rpcFor(nativeId, method, params);
+        const goal = change.action === "clear" || result.goal == null ? null : sessionGoalSchema.parse(result.goal);
+        this.goalAvailable.add(nativeId);
+        // A live update can overtake a snapshot request. Never overwrite it with
+        // the older response (especially a null read from just before /goal set).
+        if ((this.goalRevision.get(nativeId) ?? 0) === revision && this.isNews(`goal:${nativeId}`, goal))
+            this.host?.update(this.id, nativeId, { sessionUpdate: "ls_goal", goal });
+        return goal;
+    }
+    async announceGoal(nativeId) {
+        try {
+            await this.goal(nativeId, { action: "get" });
+            await this.announceCommands(nativeId);
+        }
+        catch (error) {
+            // Older Codex builds do not implement Goals; ordinary sessions still work.
+            this.host?.log(`[codex] goal unavailable: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     /** Model, reasoning effort and permissions apply from the next turn on. */
     async setConfig(nativeId, optionId, value) {
         const models = await this.loadModels();
@@ -880,15 +1104,18 @@ export class CodexDriver {
         this.announced.set(key, text);
         return true;
     }
-    loadSkills(cwd) {
+    loadSkills(cwd, forceReload = false) {
         const key = cwd ?? "";
         let loading = this.skills.get(key);
         if (!loading) {
-            loading = this.rpc("skills/list", cwd ? { cwds: [cwd] } : {})
+            loading = this.rpc("skills/list", { ...(cwd ? { cwds: [cwd] } : {}), ...(forceReload ? { forceReload } : {}) })
                 .then((result) => result.data.flatMap((entry) => entry.skills ?? []).filter((skill) => skill.enabled !== false && skill.name && skill.path))
                 .catch((error) => {
-                this.skills.delete(key);
+                if (this.skills.get(key) === loading)
+                    this.skills.delete(key);
                 this.host?.log(`[codex] skills/list failed: ${error instanceof Error ? error.message : String(error)}`);
+                if (forceReload)
+                    throw error;
                 return [];
             });
             this.skills.set(key, loading);
@@ -897,10 +1124,19 @@ export class CodexDriver {
     }
     /** What `/` offers on a device: the commands above, then the skills this project can use. */
     async announceCommands(nativeId) {
+        // Built-ins must be usable even while skill discovery is slow or unavailable.
+        if (!this.announced.has(`commands:${nativeId}`)) {
+            this.isNews(`commands:${nativeId}`, COMMANDS);
+            this.host?.update(this.id, nativeId, { sessionUpdate: "available_commands_update", availableCommands: COMMANDS });
+        }
+        const revision = this.skillsRevision;
         const skills = await this.loadSkills(this.cwds.get(nativeId));
+        if (revision !== this.skillsRevision)
+            return;
         const taken = new Set(COMMANDS.map((command) => command.name));
         const availableCommands = [
             ...COMMANDS,
+            ...(this.goalAvailable.has(nativeId) ? [{ name: "goal", description: "设置、查看、暂停、继续或清除持续目标", hint: "目标 / pause / resume / clear" }] : []),
             ...skills
                 .filter((skill) => !taken.has(skill.name))
                 .map((skill) => ({
@@ -1044,6 +1280,7 @@ export class CodexDriver {
             // (What is joined in Codex's background server is still there.)
             if (this.inShared.has(threadId))
                 continue;
+            this.loseTasks(threadId);
             this.attached.delete(threadId);
             this.threads.delete(threadId);
             this.host?.update(this.id, threadId, { sessionUpdate: "ls_status", state: "offline" });
@@ -1082,6 +1319,23 @@ export class CodexDriver {
         return state;
     }
     onNotification(method, params, from) {
+        if (method === "skills/changed") {
+            this.skillsRevision++;
+            this.skills.clear();
+            for (const id of this.attached)
+                void this.announceCommands(id);
+            return;
+        }
+        if (method === "thread/goal/updated" || method === "thread/goal/cleared") {
+            const id = params?.threadId;
+            if (id) {
+                this.goalRevision.set(id, (this.goalRevision.get(id) ?? 0) + 1);
+                if (this.attached.has(id) && !this.goalAvailable.has(id)) {
+                    this.goalAvailable.add(id);
+                    void this.announceCommands(id);
+                }
+            }
+        }
         if (method === "thread/deleted") {
             // Deleted in the TUI or another client.
             const threadId = params?.threadId;
@@ -1122,10 +1376,26 @@ export class CodexDriver {
             return;
         }
         this.noteSpawns(params);
+        if (method === "item/completed" && typeof threadId === "string") {
+            const item = params.item;
+            const task = this.host?.tasks(this.id, threadId).find((task) => task.id === item?.id);
+            if (task && task.state === "running") {
+                this.taskRevisions.set(threadId, (this.taskRevisions.get(threadId) ?? 0) + 1);
+                const stopped = this.stoppingTasks.delete(`${threadId}:${task.id}`);
+                this.publishTask(threadId, { ...task, state: stopped ? "stopped" : item?.exitCode === 0 ? "completed" : item?.exitCode != null || item?.status === "failed" ? "failed" : "unknown", endedAt: Date.now(), exitCode: item?.exitCode ?? undefined, canStop: false });
+            }
+        }
+        if (method === "item/completed" && typeof threadId === "string") {
+            const frame = codexPreview(params.item);
+            if (frame)
+                this.host?.preview?.(this.id, threadId, frame);
+        }
         for (const mapped of mapNotification(method, params, (id) => this.stateOf(id))) {
             const update = from === "shared" && mapped.update.sessionUpdate === "ls_permission_resolved"
                 ? { ...mapped.update, requestId: sharedRequestId(mapped.update.requestId) }
                 : mapped.update;
+            if (update.sessionUpdate === "ls_goal" && !this.isNews(`goal:${mapped.threadId}`, update.goal))
+                continue;
             if (update.sessionUpdate === "tool_call")
                 this.rememberTitle(update.toolCallId, update.title);
             if (update.sessionUpdate === "ls_permission_resolved") {
@@ -1154,8 +1424,10 @@ export class CodexDriver {
                 continue;
             if (update.state === "started")
                 this.fresh.delete(mapped.threadId);
-            else
+            else {
+                void this.syncTasks(mapped.threadId);
                 this.considerRelease(mapped.threadId);
+            }
         }
     }
     /** Remembers which spawnAgent call each new sub-agent thread belongs to. */
@@ -1230,6 +1502,7 @@ export class CodexDriver {
         const joined = [...this.inShared].filter((threadId) => this.attached.delete(threadId));
         this.inShared.clear();
         for (const threadId of joined) {
+            this.loseTasks(threadId);
             const turnId = this.stateOf(threadId).activeTurnId;
             this.threads.delete(threadId);
             // Whether the turn goes on is told again when the thread is joined again.