/goal 命令实现剖析

type SessionHook =
        | { type: "prompt"; prompt: string }
        | { type: "function"; id: string; timeout: number; callback: Function; errorMessage?: string }
        | { type: "command"; command: string; /* … */ };
      
      type HookEntry = {
        matcher: string;                    // 空字符串表示"无 matcher" → /goal 用空串
        skillRoot?: string;                 // /goal 用 undefined（区别于 skill 注入的 hook）
        hooks: SessionHook[];
      };
      
      interface SessionHooksRegistry {
        add(sessionId: string, event: "Stop" | "SubagentStop" | /* … */,
            matcher: string, hook: SessionHook, skillRoot?: string): void;
        remove(sessionId: string, event: string, hook: SessionHook): void;
      }
      
      // 见 cli.js L376600 iD_ → OI7：upsert by (matcher, skillRoot)
      function installHook /* iD_ */ (
        setAppState: AppStateSetter,
        sessionId: string,
        event: "Stop",
        matcher: string,
        hook: SessionHook,
      ): void;
      
      // 取出该 session 该事件下的所有 HookEntry
      function getHooksForEvent /* twH */ (
        state: AppState, sessionId: string, event: string,
      ): Map<string, HookEntry[]>;

type GoalReply =
        | { type: "text";  value: string }
        | { type: "query"; value: string; prompt: string };
      
      async function handleGoalText /* UV3 */ (input: string, ctx: AppStateCtx): Promise<GoalReply> {
        const q = input.trim();
      
        // (1) 空输入 → 显示当前状态
        if (q === "") {
          const goal = ctx.getAppState().activeGoal;
          if (!goal) return { type: "text", value: "No goal set. Usage: `/goal <condition>`" };
      
          const turns = goal.iterations === 0
            ? "not yet evaluated"
            : `${goal.iterations} ${pluralize(goal.iterations, "turn")}`;
          const tail = goal.lastReason ? `\n${formatLastCheckLine(goal.lastReason)}` : "";
          return { type: "text", value: `Goal active: ${goal.condition} (${turns})${tail}` };
        }
      
        // (2) clear/stop/off/reset/none/cancel → 清除
        if (isClearKeyword(q)) {
          const cleared = clearGoal(ctx);
          return { type: "text", value: cleared === null ? "No goal set" : `Goal cleared: ${cleared}` };
        }
      
        // (3) 字符上限
        if (q.length > MAX_CONDITION_LENGTH) {
          trackWithCode("goal_set", "too_long");
          return {
            type: "text",
            value: `Goal condition is limited to ${MAX_CONDITION_LENGTH} characters (got ${q.length})`,
          };
        }
      
        // (4) 设置 → 失败返回错误文本；成功立即触发一次带运行时指令的 query
        const errMsg = setGoal(q, ctx);
        if (errMsg !== null) return { type: "text", value: errMsg };
        return { type: "query", value: `Goal set: ${q}`, prompt: buildGoalDirective(q) };
      }

function isClearKeyword /* xD6 */ (s: string): boolean {
        return CLEAR_KEYWORDS.has(s.toLowerCase());
      }
      
      function formatLastCheckLine /* hjK */ (reason: string): string {
        return `Last check: ${firstLine(reason.trim())}`;
      }
      
      // 准入闸门
      function checkGoalGate /* Wu8 */ (): { message: string; code: "policy_gate" | "trust_gate" } | null {
        if (isHooksDisabledByPolicy()) return { message: POLICY_GATE_MESSAGE, code: "policy_gate" };
        if (!isNonInteractive() && !isWorkspaceTrusted()) {
          return { message: TRUST_GATE_MESSAGE, code: "trust_gate" };
        }
        return null;
      }
      
      // 列出本会话所有"由 /goal 注入"的 Stop hooks
      function listGoalStopHooks /* mD6 */ (state: AppState, sessionId: string): SessionHook[] {
        const out: SessionHook[] = [];
        for (const entry of getHooksForEvent(state, sessionId, "Stop").get("Stop") ?? []) {
          if (entry.matcher !== "" || entry.skillRoot !== undefined) continue; // 用户态 goal 标识
          for (const hook of entry.hooks) if (hook.type === "prompt") out.push(hook);
        }
        return out;
      }
      
      // 构造 sentinel 附件消息（UI 不渲染，仅作为 resume 锚点）
      function makeGoalSentinelMessage /* EjK */ (met: boolean, condition: string): Message {
        return {
          type: "attachment",
          uuid: crypto.randomUUID(),
          timestamp: new Date().toISOString(),
          attachment: { type: "goal_status", met, sentinel: true, condition },
        };
      }
      
      // 设置 goal —— 成功返回 null，失败返回展示给用户的错误文本
      function setGoal /* YoH */ (condition: string, ctx: AppStateCtx): string | null {
        const gate = checkGoalGate();
        if (gate !== null) {
          trackWithCode("goal_set", gate.code);
          return gate.message;
        }
      
        const sessionId = getSessionId();
      
        // 同时只允许一个 goal hook：先清掉旧的
        for (const old of listGoalStopHooks(ctx.getAppState(), sessionId)) {
          ctx.sessionHooksRegistry.remove(sessionId, "Stop", old);
        }
      
        // ⭐ 把 condition 注入为 prompt 型 Stop hook
        ctx.sessionHooksRegistry.add(
          sessionId, "Stop", "",
          { type: "prompt", prompt: condition },
        );
      
        const goal: ActiveGoal = {
          condition,
          iterations: 0,
          setAt: Date.now(),
          tokensAtStart: getOutputTokenCount(),
        };
        ctx.setAppState(s => ({ ...s, activeGoal: goal }));
        ctx.applyMessageOp({ type: "append", messages: [makeGoalSentinelMessage(false, condition)] });
      
        track("tengu_stop_hook_added", { promptLength: condition.length, via: "goal" });
        showToast("goal_set");
        return null;
      }
      
      // 清除 goal —— 没有则返回 null，否则返回被清掉的 condition
      function clearGoal /* woH */ (ctx: AppStateCtx): string | null {
        const sessionId = getSessionId();
        const existing = listGoalStopHooks(ctx.getAppState(), sessionId);
        if (existing.length === 0) return null;
      
        const cleared = (existing[0] as { type: "prompt"; prompt: string }).prompt;
        for (const h of existing) ctx.sessionHooksRegistry.remove(sessionId, "Stop", h);
      
        ctx.setAppState(s => (s.activeGoal === undefined ? s : { ...s, activeGoal: undefined }));
        ctx.applyMessageOp({ type: "append", messages: [makeGoalSentinelMessage(true, cleared)] });
      
        track("tengu_stop_hook_removed", { via: "goal" });
        return cleared;
      }

// 主循环消费 hook 产生的 message stream
      for await (const frame of hookStream) {
        // 帮助函数：把 frame 上的 hook 描述符映射回当前注册表里的那条 hook
        // (Z = (b) => { … }，对应 cli.js L418182)
        const matchedHook = (frame.hook && hookStillRegistered(frame.hook)) ? frame.hook : undefined;
      
        // ── 成功路径：hook 没阻塞 → 视为 goal 达成 ──────────────────────────────
        if (frame.message?.type === "attachment") {
          const att = frame.message.attachment;
          const isStop = att.hookEvent === "Stop" || att.hookEvent === "SubagentStop";
      
          if (isStop && att.type === "hook_success" && matchedHook?.type === "prompt") {
            ctx.sessionHooksRegistry.remove(getSessionId(), "Stop", matchedHook);
            const cur = ctx.getAppState().activeGoal;
      
            if (cur?.condition === matchedHook.prompt) {
              const iterations = cur.iterations + 1;
              const durationMs = Date.now() - cur.setAt;
              const tokens     = getOutputTokenCount() - cur.tokensAtStart;
      
              yield { type: "active_goal", value: undefined };       // 清状态
              yield wrapAttachmentAsMessage({
                type: "goal_status",
                met: true,
                condition: matchedHook.prompt,
                reason: frame.stopReason,
                iterations, durationMs, tokens,
              });
      
              track("tengu_goal_achieved", {
                promptLength: matchedHook.prompt.length, iterations, durationMs, tokens,
              });
              showToast("goal_met");
            }
          }
        }
      
        // ── 失败路径：hook 阻塞 → 未达成，把 reason 反馈给模型继续干活 ──────────
        if (frame.blockingError) {
          // 这条 meta 消息会作为系统提示注入下一轮 LLM 调用
          const feedback = makeUserMessage({
            content: formatBlockingError(frame.blockingError),   // "Stop hook feedback:\n<reason>"
            isMeta: true,
          });
          yield feedback;
      
          const cur = ctx.getAppState().activeGoal;
          if (matchedHook?.type === "prompt" && cur?.condition === matchedHook.prompt) {
            yield {
              type: "active_goal",
              value: { ...cur, iterations: cur.iterations + 1, lastReason: frame.stopReason },
            };
            yield wrapAttachmentAsMessage({
              type: "goal_status",
              met: false,
              condition: matchedHook.prompt,
              reason: frame.stopReason,
            });
          }
        }
      }

// 找最近一条未达成的 goal 锚点（含 sentinel 与失败反馈）
      export function findGoalToRestore /* _mK */ (messages: Message[] | undefined): string | null {
        if (!messages) return null;
        for (let i = messages.length - 1; i >= 0; i--) {
          const m = messages[i];
          if (m?.type !== "attachment" || m.attachment.type !== "goal_status") continue;
          return m.attachment.met ? null : m.attachment.condition;
        }
        return null;
      }
      
      export function restoreGoalFromTranscript /* Rg3 */ (
        messages: Message[],
        setAppState: AppStateSetter,
      ): void {
        const condition = findGoalToRestore(messages);
        const gate = condition !== null ? checkGoalGate() : null;
        if (gate !== null) trackWithCode("goal_set", gate.code);
      
        if (condition === null || gate !== null) {
          setAppState(s => (s.activeGoal === undefined ? s : { ...s, activeGoal: undefined }));
          return;
        }
      
        installHook(setAppState, getSessionId(), "Stop", "",
                    { type: "prompt", prompt: condition });
      
        setAppState(s => ({
          ...s,
          activeGoal: {
            condition,
            iterations: 0,
            setAt: Date.now(),
            tokensAtStart: getOutputTokenCount(),
          },
        }));
      
        track("tengu_goal_restored_on_resume", { promptLength: condition.length });
      }