@genee/omp-opsx-addon 0.1.0

package/lib/session-title.ts

@@ -0,0 +1,186 @@
+import type { AgentEndEvent, ExtensionAPI, ExtensionContext } from '@oh-my-pi/pi-coding-agent';
+import { readFile, readdir } from 'fs/promises';
+
+type AgentMessage = AgentEndEvent['messages'][number];
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { buildPrompt, parseState, detectChangeName } from './state.js';
+import { notify } from './notify.js';
+import { countTasks } from './openspec-tasks.js';
+
+interface AuthEntry {
+    type: string;
+    key?: string;
+}
+interface PiSettings {
+    defaultProvider?: string;
+    defaultModel?: string;
+}
+
+const ENDPOINTS: Record<string, string> = {
+    deepseek: 'https://api.deepseek.com',
+    openai: 'https://api.openai.com/v1',
+    anthropic: 'https://api.anthropic.com',
+    google: 'https://generativelanguage.googleapis.com/v1beta',
+    'zhipuai-coding-plan': 'https://open.bigmodel.cn/api/paas/v4',
+    zhipuai: 'https://open.bigmodel.cn/api/paas/v4',
+};
+
+async function readJSON<T>(path: string): Promise<T | null> {
+    try {
+        return JSON.parse(await readFile(path, 'utf-8')) as T;
+    } catch {
+        return null;
+    }
+}
+
+async function findCallableProvider(
+    directory: string,
+): Promise<{ apiKey: string; baseURL: string; model: string } | null> {
+    const agentDir = join(homedir(), '.omp', 'agent');
+    const globalSettings = (await readJSON<PiSettings>(join(agentDir, 'settings.json'))) ?? {};
+    const projectSettings = (await readJSON<PiSettings>(join(directory, '.omp', 'settings.json'))) ?? {};
+    const settings = { ...globalSettings, ...projectSettings };
+
+    const targetPID = settings.defaultProvider?.trim() || 'deepseek';
+    const targetModel = settings.defaultModel?.trim() || 'deepseek-v4-flash';
+
+    const auth = await readJSON<Record<string, AuthEntry>>(join(agentDir, 'auth.json'));
+    if (auth?.[targetPID]?.key) {
+        return {
+            apiKey: auth[targetPID].key!,
+            baseURL: ENDPOINTS[targetPID] || `https://api.${targetPID}.com/v1`,
+            model: targetModel,
+        };
+    }
+
+    if (auth) {
+        for (const [pid, entry] of Object.entries(auth)) {
+            if (entry.key) {
+                return {
+                    apiKey: entry.key,
+                    baseURL: ENDPOINTS[pid] || `https://api.${pid}.com/v1`,
+                    model: targetModel,
+                };
+            }
+        }
+    }
+
+    return null;
+}
+
+async function generateTitle(context: string, directory: string): Promise<string> {
+    const prov = await findCallableProvider(directory);
+    if (!prov) throw new Error('no provider available');
+
+    const prompt = buildPrompt(context);
+    const body: Record<string, unknown> = {
+        model: prov.model,
+        messages: [{ role: 'user', content: prompt }],
+        max_tokens: 80,
+        temperature: 0.3,
+    };
+    if (!prov.model.startsWith('o')) body.thinking = { type: 'disabled' };
+
+    const res = await fetch(`${prov.baseURL}/chat/completions`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${prov.apiKey}` },
+        body: JSON.stringify(body),
+    });
+
+    if (!res.ok) throw new Error(`API ${res.status}`);
+    const json = (await res.json()) as {
+        choices?: Array<{ message?: { content?: string; reasoning_content?: string } }>;
+    };
+    const msg = json.choices?.[0]?.message;
+    return msg?.content?.trim() || msg?.reasoning_content?.trim() || '';
+}
+
+function messageText(msg: AgentMessage): string {
+    if (!('content' in msg)) return '';
+    const content = msg.content;
+    if (typeof content === 'string') return content.trim();
+    if (!Array.isArray(content)) return '';
+    return content
+        .filter((p): p is { type: 'text'; text: string } => typeof p === 'object' && p !== null && p.type === 'text')
+        .map((p) => (p as any).text)
+        .join('\n')
+        .trim();
+}
+
+function extractContext(messages: AgentMessage[]): string {
+    const turns: string[] = [];
+    let cur = '';
+    for (const m of messages) {
+        if (!('role' in m)) continue;
+        if (m.role !== 'user' && m.role !== 'assistant') continue;
+        const t = messageText(m);
+        if (!t) continue;
+        if (m.role === 'user') {
+            if (cur) turns.push(cur);
+            cur = `User: ${t.slice(0, 400)}`;
+        } else {
+            cur += `\nA: ${t.slice(0, 400)}`;
+        }
+    }
+    if (cur) turns.push(cur);
+    return turns.slice(-6).join('\n\n');
+}
+
+async function findActiveChange(context: string, dir: string): Promise<string | undefined> {
+    const fromCtx = detectChangeName(context);
+    if (fromCtx) return fromCtx;
+    const ch = context.match(/CHANGE:\s*(\S+)/i);
+    if (ch) return ch[1];
+    const changesDir = join(dir, 'openspec', 'changes');
+    if (!existsSync(changesDir)) return undefined;
+    try {
+        const entries = await readdir(changesDir);
+        return entries.find((e) => e !== 'archive');
+    } catch {
+        return undefined;
+    }
+}
+
+export function createTitleGenerator(pi: ExtensionAPI, directory: string, warn: (msg: string) => void) {
+    const titleCache = new Map<string, string>();
+    const stateCache = new Map<string, string>();
+
+    return {
+        async onAgentEnd(event: AgentEndEvent, ctx: ExtensionContext) {
+            try {
+                const sessionId = ctx.sessionManager.getSessionFile() || 'default';
+                const ctx2 = extractContext(event.messages);
+                if (!ctx2) return;
+                if (titleCache.has(sessionId)) return;
+
+                const raw = await generateTitle(ctx2, directory);
+                const p = parseState(raw);
+
+                let progress: { current: number; total: number } | null = null;
+                if (p.state === 'implementing') {
+                    const changeName = await findActiveChange(ctx2, directory);
+                    if (changeName) progress = await countTasks(directory, changeName);
+                }
+
+                const progressTag = progress ? `${progress.current}/${progress.total}` : '';
+                const prefix = progress ? `${p.emoji}${progressTag}` : p.emoji;
+                const title = prefix ? `${prefix} ${p.title}` : p.title;
+
+                if (titleCache.get(sessionId) !== title) {
+                    titleCache.set(sessionId, title);
+                    pi.setSessionName(title);
+                }
+
+                const lastState = stateCache.get(sessionId);
+                if (p.state !== 'none' && p.state !== lastState) {
+                    stateCache.set(sessionId, p.state);
+                    notify('omp', `${p.emoji} ${p.state}: ${detectChangeName(ctx2) || p.title}`);
+                }
+            } catch (e) {
+                warn(`[omp-opsx-addon] session title generation failed: ${e}`);
+            }
+        },
+    };
+}

package/lib/session-usage.ts

@@ -0,0 +1,252 @@
+/**
+ * Per-session token-usage recorder feeding the usage widget's consumption
+ * waveforms (design Decision 5, revised: usage-RATE source).
+ *
+ * `message_end` fires once per assistant message with the turn's exact
+ * `usage.totalTokens`. Each plugin instance has its own recorder instance
+ * (see index.ts for the architecture). Subagent usage is captured through
+ * the eventBus channel mechanism (TASK_SUBAGENT_EVENT_CHANNEL) where the
+ * primary plugin subscribes to subagent events and records them with
+ * stream-specific tracking to prevent cross-stream contamination. Sessions in
+ * other processes instantiate their own recorder and join the aggregated
+ * view through the shared usage cache's `sessionUsage` node, which each
+ * process writes for its own session id and everyone aggregates on read
+ * (see usage-poller.ts). The recorder owns the process's counter, the write
+ * throttle, and the session-end cleanup; the poller owns the on-disk merge.
+ *
+ * Multi-stream tracking: The recorder maintains per-stream baselines
+ * (Map<streamKey, Map<provider, last基线>>) where each stream computes its own
+ * delta (usage.totalTokens − last[streamKey][provider], first call records
+ * full baseline). Global totals/seconds aggregate all stream deltas, so streams
+ * never compare across each other (no cross-stream MAX swallowing). The default
+ * streamKey is the recorder's current sessionId (legacy primary path).
+ * setSessionId() only sets the global sessionId and never clears stream baselines.
+ */
+
+/** Min spacing between sessionUsage writes — 1s, matching the renderTimer so the
+ * throttle lets a fresh flush land each second (cross-process latency ≤1s). */
+export const SESSION_USAGE_WRITE_MS = 1_000;
+
+import type { UsageBucket } from "./usage-estimator.js";
+
+/** Where the recorder persists its per-session totals. */
+export interface SessionUsageSink {
+    /** Persist the session's totals. Returns false when nothing was persisted
+     * (lock/I/O failure) — the recorder keeps its dirty flag so the next
+     * flush retries the same totals; nothing is lost. */
+    write(sessionId: string, perProvider: Record<string, ProviderUsageTotals>): boolean;
+    remove(sessionId: string): void;
+    /** Optional: event-level per-second delta hook (the Redis mirror's event
+     * source). `record()` calls it synchronously for every `deltaTotal > 0`
+     * (before updating totals), skipping while no session id is set. The
+     * implementation MUST NOT throw — the recorder wraps the call in a guard
+     * so a failing hook can never break accounting. */
+    onDelta?(sessionId: string, provider: string, secNow: string, deltaTotal: number): void;
+}
+
+/** Per-provider cumulative totals PLUS the per-second delta map (timestamped
+ * increments; the waveform consumes the per-second sequence directly so a
+ * throttled flush can never mis-attribute tokens to the wrong second). */
+export interface ProviderUsageTotals extends UsageBucket {
+    /** Per-second delta map: unix second → tokens (the waveform source). */
+    seconds?: Record<string, number>;
+}
+
+/** Per-session token-usage recorder with multi-stream support.
+ *
+ * The recorder maintains a global sessionId for legacy compatibility and
+ * supports independent stream tracking (e.g., primary vs subagent streams)
+ * to prevent cross-stream contamination. Each stream maintains its own
+ * baseline per-provider, and deltas are computed independently and then
+ * aggregated into the global totals. This prevents setSessionId() from
+ * clearing other streams' baselines and ensures streams don't swallow each
+ * other's contributions (MAX operation per stream, not across streams).
+ */
+export interface SessionUsageRecorder {
+    /** Set the global session id for legacy primary stream (call once on claim). */
+    setSessionId(id: string): void;
+    /** Get the global session id. */
+    sessionId(): string;
+    /** Record usage with optional stream key for independent tracking. */
+    record(provider: string, usage: UsageBucket, streamKey?: string): void;
+    /** Throttled flush to the sink (auto-called on record; exposes for testing). */
+    flush(): boolean;
+    /** Session shutdown: clean up dirty state and persist final totals. */
+    remove(): void;
+    /** Get current totals (for testing only). */
+    totals(): Map<string, ProviderUsageTotals>;
+}
+
+export function createSessionUsageRecorder(
+    sink: SessionUsageSink,
+    opts?: { writeMs?: number; now?: () => number },
+): SessionUsageRecorder {
+    const writeMs = opts?.writeMs ?? SESSION_USAGE_WRITE_MS;
+    const now = opts?.now ?? Date.now;
+    
+    let sessionId = '';
+    let dirty = false;
+    let lastFlush = 0;
+    
+    // Global totals (aggregated from all streams)
+    const totals: Record<string, ProviderUsageTotals> = {};
+    const seconds: Record<string, Record<string, number>> = {};
+    
+    // Per-stream baselines: Map<streamKey, Map<provider, last基线>>
+    const streamBaselines = new Map<string, Map<string, UsageBucket>>();
+    
+    // Helper: get or create stream baseline map
+    const getStreamBaselines = (streamKey: string): Map<string, UsageBucket> => {
+        if (!streamBaselines.has(streamKey)) {
+            streamBaselines.set(streamKey, new Map());
+        }
+        return streamBaselines.get(streamKey)!;
+    };
+    
+    // Helper: get stream-specific baseline
+    const getStreamBaseline = (streamKey: string, provider: string): UsageBucket => {
+        const baselines = getStreamBaselines(streamKey);
+        if (!baselines.has(provider)) {
+            baselines.set(provider, { total: 0, input: 0, output: 0 });
+        }
+        return baselines.get(provider)!;
+    };
+    
+    // Helper: update stream baseline
+    const updateStreamBaseline = (streamKey: string, provider: string, usage: UsageBucket): void => {
+        const baselines = getStreamBaselines(streamKey);
+        baselines.set(provider, { ...usage });
+    };
+    
+    // Helper: compute delta from baseline
+    const computeDelta = (streamKey: string, provider: string, current: UsageBucket): UsageBucket => {
+        const baseline = getStreamBaseline(streamKey, provider);
+        return {
+            total: Math.max(0, current.total - baseline.total),
+            input: Math.max(0, current.input - baseline.input),
+            output: Math.max(0, current.output - baseline.output),
+        };
+    };
+    
+    return {
+        setSessionId(id: string): void {
+            sessionId = id;
+            // IMPORTANT: setSessionId only sets the global sessionId
+            // and NEVER clears stream baselines to prevent cross-stream contamination
+        },
+        
+        sessionId(): string {
+            return sessionId;
+        },
+        
+        record(provider: string, usage: UsageBucket, streamKey?: string): void {
+            if (!sessionId) return; // No-op before claim
+            
+            // Validate finite token counts
+            if (!Number.isFinite(usage.total) || !Number.isFinite(usage.input) || !Number.isFinite(usage.output)) {
+                return;
+            }
+            
+            // Use streamKey or default to sessionId for legacy compatibility
+            const key = streamKey ?? sessionId;
+            
+            // Compute stream-specific delta
+            const delta = computeDelta(key, provider, usage);
+            
+            // Skip if no delta (avoid unnecessary writes)
+            if (delta.total === 0 && delta.input === 0 && delta.output === 0) {
+                return;
+            }
+            
+            // Update stream baseline to current usage (MAX for monotonicity within stream)
+            updateStreamBaseline(key, provider, usage);
+            
+            // Aggregate delta into global totals
+            if (!totals[provider]) {
+                totals[provider] = { total: 0, input: 0, output: 0, seconds: {} };
+            }
+            totals[provider].total += delta.total;
+            totals[provider].input += delta.input;
+            totals[provider].output += delta.output;
+            
+            // Update per-second deltas (global, not per-stream)
+            const secNow = Math.floor(now() / 1000).toString();
+            if (!totals[provider].seconds) {
+                totals[provider].seconds = {};
+            }
+            totals[provider].seconds![secNow] = (totals[provider].seconds![secNow] ?? 0) + delta.total;
+            
+            dirty = true;
+            
+            // Event-level delta mirror (Redis)
+            if (delta.total > 0) {
+                try {
+                    sink.onDelta?.(sessionId, provider, secNow, delta.total);
+                } catch {
+                    // Silently ignore errors in mirror hook
+                }
+            }
+            
+            // Throttled flush
+            const nowVal = now();
+            if (nowVal - lastFlush >= writeMs) {
+                lastFlush = nowVal;
+                if (flushInternal()) {
+                    dirty = false;
+                }
+            }
+        },
+        
+        flush(): boolean {
+            return flushInternal();
+        },
+        
+        remove(): void {
+            if (sessionId) {
+                sink.remove(sessionId);
+            }
+            // Clear internal state
+            sessionId = '';
+            Object.keys(totals).forEach(k => delete totals[k]);
+            Object.keys(seconds).forEach(k => delete seconds[k]);
+            streamBaselines.clear();
+            dirty = false;
+            lastFlush = 0;
+        },
+        
+        totals(): Map<string, ProviderUsageTotals> {
+            return new Map(Object.entries(totals).map(([k, v]) => [k, { ...v }]));
+        },
+    };
+    
+    function flushInternal(): boolean {
+        if (!sessionId || !dirty) {
+            return true;
+        }
+        
+        try {
+            return sink.write(sessionId, totals);
+        } catch {
+            return false;
+        }
+    }
+}
+
+/**
+ * Extract the billable usage of an assistant `message_end` / `message_update`
+ * event payload. Returns `undefined` for non-usage events.
+ */
+export function assistantUsageOf(
+    message: unknown,
+): { provider: string; usage: UsageBucket } | undefined {
+    if (!message || typeof message !== 'object') return undefined;
+    // External event payload; structural guard instead of a full schema parse.
+    const m = message as { role?: unknown; provider?: unknown; usage?: { totalTokens?: unknown; input?: unknown; output?: unknown; cacheRead?: unknown } };
+    if (m.role !== 'assistant' || typeof m.provider !== 'string' || m.provider === '') return undefined;
+    const total = m.usage?.totalTokens;
+    if (typeof total !== 'number' || !Number.isFinite(total)) return undefined;
+    const input = (typeof m.usage?.input === 'number' && Number.isFinite(m.usage.input) ? m.usage.input : 0) +
+        (typeof m.usage?.cacheRead === 'number' && Number.isFinite(m.usage.cacheRead) ? m.usage.cacheRead : 0);
+    const output = typeof m.usage?.output === 'number' && Number.isFinite(m.usage.output) ? m.usage.output : 0;
+    return { provider: m.provider, usage: { total, input, output } };
+}

package/lib/state.ts

@@ -0,0 +1,95 @@
+const STATE_MAP: Record<string, string> = {
+    exploring: '💡',
+    proposing: '📝',
+    implementing: '👨🏻‍💻',
+    reviewing: '🛡️',
+    complete: '✅',
+    blocked: '🚫',
+};
+
+export interface StateResult {
+    state: string;
+    emoji: string;
+    title: string;
+    changeName?: string;
+}
+
+export function parseState(raw: string): StateResult {
+    const lines = raw
+        .replace(/<think[\s\S]*?<\/think>\s*/g, '')
+        .split('\n')
+        .map((l) => l.trim())
+        .filter(Boolean);
+
+    let state = 'none';
+    let title = '';
+
+    for (const line of lines) {
+        const lower = line.toLowerCase();
+        if (lower.startsWith('state:')) {
+            state = line
+                .replace(/^state:\s*/i, '')
+                .trim()
+                .toLowerCase();
+        } else if (lower.startsWith('title:')) {
+            title = line.replace(/^title:\s*/i, '').trim();
+        }
+    }
+
+    if (!title) {
+        title = lines.find((l) => !/^(state|change|progress):/i.test(l)) || 'Untitled';
+    }
+
+    // strip state emojis from title if AI included them (repeatedly)
+    const emojis = Object.values(STATE_MAP).sort((a, b) => b.length - a.length);
+    while (true) {
+        const before = title;
+        for (const e of emojis) {
+            if (title.startsWith(e)) {
+                title = title.slice(e.length).trim();
+                break;
+            }
+        }
+        if (title === before) break;
+    }
+
+    return { state, emoji: state !== 'none' ? STATE_MAP[state] || '' : '', title };
+}
+
+export function detectChangeName(context: string): string | undefined {
+    const match = context.match(/openspec\/changes\/([a-z0-9-]+)/i);
+    return match?.[1];
+}
+
+export function buildPrompt(context: string): string {
+    return `你是会话标题生成器。根据对话内容判断当前 OpenSpec 工作流状态并生成标题。
+
+## 工作流状态
+
+- exploring: 💡 探索、讨论或分析阶段
+- proposing: 📝 正在创建提案或其 artifacts
+- implementing: 👨🏻‍💻 @coder 正在实现任务
+- reviewing: 🛡️ @reviewer 正在审查代码
+- complete: ✅ 实现已通过审查
+- blocked: 🚫 实现或审查被阻塞
+
+## 输出格式（严格遵守）
+
+第一行: state: <状态名>（如果非 OpenSpec 相关，输出 state: none）
+第二行: title: <标题文本，≤50字符>
+
+## 规则
+
+- 使用中文
+- 标题 ≤50 字符
+- 保留技术术语、文件名
+- 如果对话不涉及 OpenSpec 变更，state 输出 none，title 不加前缀
+- state 不明确时用最早的相关状态
+- 不要解释，只输出两行
+
+## 对话内容
+
+${context}
+
+Output:`;
+}

package/lib/system-prompt.ts

@@ -0,0 +1,160 @@
+import type { ChangeInfo } from './change-scanner.js';
+import type { ResolvedOpsxConfig } from './unified-config.js';
+import type { SelectorResult } from './model-selector.js';
+
+/** Base prompt is ~17 lines; reserve headroom for truncation notice. */
+export const MAX_PROMPT_LINES = 65;
+export const MAX_LISTED_CHANGES = 25;
+
+
+function formatChangeLine(change: ChangeInfo): string {
+    if (change.status === 'doing') {
+        return `• ${change.name}: doing (${change.completed}/${change.total})`;
+    }
+    if (change.status === 'done') {
+        return `• ${change.name}: done`;
+    }
+    return `• ${change.name}: ready`;
+}
+
+function buildChangeSummary(changes: ChangeInfo[], maxListed?: number): string {
+    if (changes.length === 0) return '当前没有活跃的 OpenSpec 变更';
+
+    const limit = maxListed ?? MAX_LISTED_CHANGES;
+    const listed = changes.slice(0, limit);
+    const lines = listed.map(formatChangeLine);
+    const omitted = changes.length - listed.length;
+    if (omitted > 0) {
+        lines.push(`• … 还有 ${omitted} 个变更未列出`);
+    }
+    return lines.join('\n');
+}
+
+/** Format a single role's resolved config + selector result for the dispatch table. */
+function buildDispatchConfigLine(
+    role: string,
+    config: ResolvedOpsxConfig,
+    selector?: SelectorResult,
+): string {
+    const roleValue = config.roles[role as keyof typeof config.roles];
+    if (!roleValue) return `• ${role}: <unknown role>`;
+
+    let modelText: string;
+    if (selector?.picked) {
+        modelText = `${selector.picked.provider}/${selector.picked.id} (tier=${selector.expectedTier})`;
+    } else if (roleValue.kind === 'auto') {
+        modelText = '<no model available>';
+    } else if (roleValue.kind === 'omp-alias') {
+        modelText = `@${roleValue.alias} (OMP 解析中)`;
+    } else if (roleValue.kind === 'provider-model') {
+        modelText = `${roleValue.provider}/${roleValue.modelId}`;
+    } else {
+        modelText = roleValue.modelId;
+    }
+
+    const valueKind =
+        roleValue.kind === 'auto'
+            ? 'auto'
+            : roleValue.kind === 'omp-alias'
+                ? `@${roleValue.alias}`
+                : 'pin';
+    return `• ${role}: ${modelText} (${valueKind})`;
+}
+
+function buildDispatchConfig(
+    config: ResolvedOpsxConfig,
+    selectorResults: Record<string, SelectorResult> | undefined,
+): string {
+    return [
+        buildDispatchConfigLine('coder', config, selectorResults?.coder),
+        buildDispatchConfigLine('planner', config, selectorResults?.planner),
+        buildDispatchConfigLine('proposal-reviewer', config, selectorResults?.['proposal-reviewer']),
+        buildDispatchConfigLine('reviewer', config, selectorResults?.reviewer),
+            ].join('\n');
+}
+
+/** Static orchestration rules — identical every turn, enabling prefix cache hits.
+ *  Contains zero dynamic data (no model picks, no change status). */
+export function buildStaticPrompt(): string {
+    return `# OpenSpec 编排助手
+
+严格按工作流驱动每个 session。
+
+## 默认行为
+- 新 session 默认进入 Explore 模式;用 \`skill://openspec-explore\` 作思考伙伴。
+- "Don't implement" guardrail 仅适用 Explore 阶段;用户确认后必须切换为编排。
+- 代码只能由 coder 子 agent 产出,禁止在 Explore 阶段直接写代码。
+
+## 提案拆分原则
+- 按契约独立性拆细提案：两部分间有可早期冻结的接口(文件格式/API/数据结构) → 拆成多个小变更,各自独立评审归档,避免又大又细的提案。
+- 大需求用纲领(roadmap)change 分层管理:纲领只列阶段/依赖/验收口径,不含实现细节;每个阶段=一个独立 change。
+- planner 接大需求先评估契约边界、输出拆分建议(契约+提案清单)待主 agent 确认后再开写;主 agent 规划时优先拆分,可并行派多个小 planner。
+- 中间审查轮按 delta 审,终审才全量复核。
+
+## 路由表
+| 意图 | 委派 |
+| 看代码/搜代码/理解架构 | task(agent:"scout", task:"探索问题") |
+| 创建/更新提案(含 Budget 估算) | task(agent:"planner", task:"...") |
+| 审查提案 | task(agent:"proposal-reviewer", task:"...") |
+| 实现变更 | task(agent:"coder", task:"...") + openspec-apply-change |
+| 审查代码实现 | task(agent:"reviewer", task:"审阅代码 + 执行全局验证（lint/单测/e2e）") |
+
+## 2 个 Loop
+- **Loop 1 – Propose → Review**:planner 完成 → proposal-reviewer → P0/P1 发回 → 通过告知用户。Propose-review loop：最多 planner→reviewer 往复 2 轮。
+- **Loop 2 – Code → Review**:coder 完成(交付前自验证)→ code-reviewer 审阅 + 全局验证 → P0/P1 发回修复 → 仅 P2+ 视为通过。Code-review loop：最多 coder→reviewer 往复 3 轮(含首次实现),reviewer 兼执行全局验证。
+- 达上限时停止自动流转，向用户说明未解决的问题并请求决策。
+
+## /goal 集成(可选)
+Planner 在 proposal 末尾输出 \`## Budget Estimate\`;主 agent 提取用于 \`/goal\`。
+
+## 自动流程协作
+coder 输出 STATUS: blocked 且含 SESSION: → 阅读阻塞原因决策;收到 P0/P1 → 修复再审。
+
+## 上下文卫生（主 session 预算）
+- 代码调研/搜代码/理解架构 → task(agent:"scout")；主 session 不亲自 read 全文调研。
+- 联网检索/外部资料 → task 子 agent（或 harness 内建 exa）；web_search 结果不直接进主上下文。
+- 大文件用 read 的 offset/limit 分段，不整文件读入。
+- 子 agent 报告即最终形态：主 session 禁止复读子 agent 已读过的文件。
+- 主 session 上下文超过 ~50k tokens：必须先委托再继续，禁止继续亲自调研。`;
+}
+
+const STATIC_LINE_COUNT = buildStaticPrompt().split('\n').length;
+
+/** Dynamic layer: Dispatch config + change status. Placed after the static
+ *  layer so only this tail is re-prefilled when it changes between turns. */
+export function buildDynamicPrompt(
+    changes: ChangeInfo[],
+    config: ResolvedOpsxConfig,
+    selectorResults?: Record<string, SelectorResult>,
+): string {
+    const dispatchCfg = buildDispatchConfig(config, selectorResults);
+
+    let maxListed = MAX_LISTED_CHANGES;
+    let result: string;
+
+    do {
+        const changeSummary = buildChangeSummary(changes, maxListed);
+        result = `## Dispatch 配置\n${dispatchCfg}\n\n## 当前变更状态\n${changeSummary}`;
+        // Reserve the '\n\n' separator line between static and dynamic layers
+        // (design.md Decision 2): 22 changes must not produce a 66-line prompt.
+        if (countPromptLines(result) <= MAX_PROMPT_LINES - (STATIC_LINE_COUNT + 1)) break;
+        maxListed = Math.floor(maxListed / 2);
+    } while (maxListed > 0);
+
+    return result;
+}
+
+/** Full prompt (static + dynamic) — for tests and single-string consumers. */
+export function buildSystemPrompt(
+    changes: ChangeInfo[],
+    config: ResolvedOpsxConfig,
+    includeChanges: boolean = true,
+    selectorResults?: Record<string, SelectorResult>,
+): string {
+    if (!includeChanges) return buildStaticPrompt();
+    return buildStaticPrompt() + '\n\n' + buildDynamicPrompt(changes, config, selectorResults);
+}
+
+export function countPromptLines(prompt: string): number {
+    return prompt.split('\n').length;
+}