@coda-console/claude 0.0.0 → 1.3.1

package/agent/auth.mjs

@@ -0,0 +1,37 @@
+import { constants } from 'node:fs';
+import { open } from 'node:fs/promises';
+import { isAbsolute } from 'node:path';
+
+// Variables that make the Claude CLI use something other than the user's normal login.
+const authOverrides = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL', 'ANTHROPIC_CUSTOM_HEADERS',
+  'CLAUDE_CODE_OAUTH_TOKEN', 'CLAUDE_CODE_OAUTH_REFRESH_TOKEN', 'CLAUDE_CODE_OAUTH_SCOPES',
+  'CLAUDE_CODE_USE_BEDROCK', 'CLAUDE_CODE_USE_VERTEX', 'CLAUDE_CODE_USE_FOUNDRY'];
+
+// Read only in the SDK driver, never in the product service or host journal.
+export async function sdkEnvironment(env = process.env) {
+  const path = env.CODA_CLAUDE_OAUTH_TOKEN_FILE;
+  // Let the SDK use the user's normal login or provider configuration. A token
+  // file is an explicit override, never a dependency on a maintainer's machine.
+  if (path === undefined) return { ...env };
+  const fail = reason => new Error(`Claude SDK setup token: ${reason}`);
+  if (!isAbsolute(path)) throw fail('file path must be absolute');
+  let file;
+  try {
+    file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    const info = await file.stat();
+    if (!info.isFile() || info.uid !== process.getuid() || (info.mode & 0o7777) !== 0o600)
+      throw fail('file must be a regular file owned by the current user with mode 0600');
+    const buffer = Buffer.alloc(8193);
+    const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+    const token = buffer.subarray(0, bytesRead).toString('utf8').replace(/\r?\n$/, '');
+    if (bytesRead > 8192 || !/^sk-ant-oat01-[A-Za-z0-9_-]+$/.test(token))
+      throw fail('file must contain one subscription OAuth token');
+    const result = { ...env };
+    for (const key of authOverrides) delete result[key];
+    result.CLAUDE_CODE_OAUTH_TOKEN = token;
+    return result;
+  } catch (error) {
+    if (error.message.startsWith('Claude SDK setup token:')) throw error;
+    throw fail('cannot read CODA_CLAUDE_OAUTH_TOKEN_FILE; choose a readable token file or remove this override to use your normal login');
+  } finally { await file?.close(); }
+}

package/agent/entry.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// The Claude agent as Coda starts it (the plugin's `contributes.agents`): Claude Code through the plugin's own Claude Agent SDK
+// (its `@anthropic-ai/claude-agent-sdk` dependency), speaking ACP and Coda's waits over standard input and output
+// (session.mjs). It ends when Coda's side of the pipe closes, when it is told to, or when its session ends.
+import { Readable, Writable } from 'node:stream';
+import { ndJsonStream } from '@agentclientprotocol/sdk';
+import { ClaudeSession } from './session.mjs';
+
+if (process.argv.includes('--help')) {
+  process.stdout.write('coda-claude: Claude Code as an ACP agent for Coda over standard input and output; no terminal UI.\n');
+} else {
+  const sdk = await import('@anthropic-ai/claude-agent-sdk');
+  for (const name of ['query', 'getSessionInfo', 'renameSession']) {
+    if (typeof sdk[name] !== 'function') throw new Error(`Claude SDK 缺少所需接口：${name}`);
+  }
+  let stopping = false;
+  const stop = async (code = 0) => {
+    if (stopping) return;
+    stopping = true;
+    // A Claude process must not outlive this one even if closing the SDK hangs; the session host has a shorter grace of its own.
+    setTimeout(() => process.exit(code || 1), 5000).unref();
+    try { await session.close(); } finally { process.stdout.write('', () => process.exit(code)); }
+  };
+  const session = new ClaudeSession({ sdk, onEnded: () => void stop(1) });
+  session.connect(ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin))).closed.then(() => stop());
+  for (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP']) process.once(signal, () => void stop());
+}

package/agent/limits.mjs

@@ -0,0 +1,87 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
+
+// The quota of the account Claude sessions run as, read from what the sessions themselves report. A setup token has no
+// profile scope, so /usage cannot be asked with it; but the CLI sends a `rate_limit_event` whenever a window's rounded
+// percentage or reset time moves, with the fraction of the window used and when it resets (SDKRateLimitInfo). Each
+// session's entry (session.mjs) writes it to `limits.json` in this plugin's state; the「Claude」panel reads it
+// (scripts/panel.mjs, docs/plugins.md「内置插件：Claude」).
+// `unifiedWindows`, an internal field of newer CLIs, carries every window each time; the top-level fields, which every
+// CLI sends, only the one that limits now.
+const labels = { five_hour: '5 小时', seven_day: '7 天', seven_day_opus: 'Opus · 7 天', seven_day_sonnet: 'Sonnet · 7 天', seven_day_overage_included: 'Fable · 7 天' };
+const used = fraction => Math.round(fraction * 100);
+
+function reported(info) {
+  const windows = info?.unifiedWindows && typeof info.unifiedWindows === 'object' ? { ...info.unifiedWindows } : {};
+  if (info?.rateLimitType && !windows[info.rateLimitType]) windows[info.rateLimitType] = info;
+  return Object.entries(windows);
+}
+
+// The latest each window was reported at, kept across restarts: events come only as a window moves, so a backend that
+// started just now would otherwise show nothing until one does. A window past its reset is no longer known, not full:
+// what was used since is not seen from here.
+// The account they are of is kept beside them, as a hash of its email (`account`): what Coda's group view compares across
+// machines, the email itself staying here. The file is the account the latest session started as (session.mjs); none
+// where Claude runs on an API key or a cloud provider, or the login does not say.
+export const accountHash = email => createHash('sha256').update(email.trim().toLowerCase()).digest('hex').slice(0, 32);
+export class ClaudeSessionLimits {
+  constructor({ path = null, now = Date.now } = {}) {
+    this.path = path; this.now = now; this.windows = new Map(); this.account = null; this.stamp = null;
+    this.read();
+  }
+  read() {
+    if (!this.path) return;
+    let stamp;
+    try { stamp = statSync(this.path).mtimeMs; } catch { return; }
+    if (stamp === this.stamp) return;
+    this.stamp = stamp; this.windows = new Map(); this.account = null;
+    try {
+      const saved = JSON.parse(readFileSync(this.path, 'utf8'));
+      for (const [key, w] of Object.entries(saved.windows)) this.take(key, w?.utilization, w?.resetsAt);
+      if (typeof saved.account === 'string' && /^[0-9a-f]{32}$/.test(saved.account)) this.account = saved.account;
+    }
+    catch { /* Not readable now: read again when it next changes. */ this.stamp = null; }
+  }
+  known() { this.read(); return this.windows.size > 0; }
+  take(key, utilization, resetsAt) {
+    if (!Object.hasOwn(labels, key) || !(Number.isFinite(utilization) && utilization >= 0) || !(Number.isSafeInteger(resetsAt) && resetsAt > 0)) return false;
+    const was = this.windows.get(key);
+    if (was?.resetsAt === resetsAt && used(was.utilization) === used(utilization)) return false;
+    this.windows.set(key, { utilization, resetsAt });
+    return true;
+  }
+  // The account a session started as, a hash or null when it is not known: from then on the file is that one's. Another
+  // than before starts the windows afresh, as another account's say nothing of it; an unknown one names none.
+  startedAs(account) {
+    if (account === this.account) return;
+    this.windows = new Map(); this.account = account;
+    this.save();
+  }
+  // What a session reports, as of the account it started as: one that started as another (still running from before a
+  // switch) says nothing of the account the file is now.
+  observe(info, account = null) {
+    if (account !== this.account) return;
+    let changed = false;
+    for (const [key, w] of reported(info)) changed = this.take(key, w?.utilization, w?.resetsAt) || changed;
+    if (changed) this.save();
+  }
+  save() {
+    if (!this.path) return;
+    try {
+      // Every Claude session writes it: a temporary file of each writer's own.
+      const temp = `${this.path}.${process.pid}.tmp`;
+      writeFileSync(temp, JSON.stringify({ version: 1, windows: Object.fromEntries(this.windows), ...(this.account ? { account: this.account } : {}) }), { mode: 0o600 });
+      renameSync(temp, this.path);
+    } catch { /* Not written: the next window that moves writes again. */ }
+  }
+  // The windows still to reset, in a fixed order: what is left of each and when it resets. None when all have passed.
+  quota() {
+    this.read();
+    const now = this.now();
+    return Object.keys(labels).flatMap(key => {
+      const w = this.windows.get(key);
+      return w && w.resetsAt * 1000 > now ? [{ id: key, label: labels[key], remainingPercent: Math.max(0, 100 - used(w.utilization)),
+        resetsAt: new Date(w.resetsAt * 1000).toISOString() }] : [];
+    });
+  }
+}

package/agent/models.mjs

@@ -0,0 +1,41 @@
+// Claude's settings as ACP config options. A model is named by the concrete ID it runs as, never by an alias: each row the
+// SDK lists is its resolved wire ID with the context variant it selects (`[1m]`), or its own value when it resolves to
+// none, and rows that come to the same ID are one model. What the row is called is kept, the ID beside it when the name
+// does not say it.
+export const MODES = [['default', '人工审批'], ['acceptEdits', '自动接受编辑'], ['plan', '规划'], ['dontAsk', '未预先允许则拒绝'], ['auto', '自动审批'],
+  ['bypassPermissions', '跳过所有审批']].map(([id, name]) => ({ id, name }));
+
+export function claudeModels(rows = []) {
+  const models = new Map();
+  for (const row of rows) {
+    if (typeof row?.value !== 'string' || !row.value) continue;
+    const variant = row.value.match(/\[[^\]]+\]$/)?.[0] ?? '', resolved = row.resolvedModel?.trim();
+    const id = resolved ? resolved + (resolved.endsWith(variant) ? '' : variant) : row.value;
+    const label = row.displayName || row.value, name = label.includes(id) ? label : `${label} (${id})`;
+    const known = models.get(id);
+    // The SDK's `default` row is the model it would pick: the row naming that model says what it is.
+    if (!known) models.set(id, { id, name, efforts: row.supportedEffortLevels ?? [], from: row.value });
+    else if (known.from === 'default') Object.assign(known, { name, from: row.value });
+  }
+  return [...models.values()];
+}
+
+// The model a native init reports: one of the list, keeping the context variant chosen when its base is the one reported.
+export function reportedModel(models, current, model) {
+  if (typeof model !== 'string' || !model) return current;
+  if (current === model || current?.replace(/\[[^\]]+\]$/, '') === model) return current;
+  return models.find(m => m.id === model)?.id ?? model;
+}
+
+const select = (id, name, category, currentValue, choices) => ({ id, name, category, type: 'select', currentValue,
+  options: choices.map(c => ({ value: c.id, name: c.name, ...(c._meta ? { _meta: c._meta } : {}) })) });
+// The effort that leaves it to the model, marked as the agent's own default (docs/agent-protocol.md): what Coda goes back to
+// when the session's effort is taken off.
+export const MODEL_EFFORT = 'default';
+// `current`: { mode, model, effort }. An effort not chosen is null: the model's own default.
+export function configOptions(models, current) {
+  const efforts = models.find(m => m.id === current.model)?.efforts ?? [];
+  return [select('mode', '审批模式', 'mode', current.mode, MODES), select('model', '模型', 'model', current.model, models),
+    ...(efforts.length ? [select('effort', '推理强度', 'thought_level', efforts.includes(current.effort) ? current.effort : MODEL_EFFORT,
+      [{ id: MODEL_EFFORT, name: '模型默认', _meta: { coda: { default: true } } }, ...efforts.map(id => ({ id, name: id }))])] : [])];
+}

package/agent/permissions.mjs

@@ -0,0 +1,68 @@
+// A tool Claude asks to use, as an ACP permission request: allow once, each rule Claude suggests to stop asking (its whole
+// sentence the option's name, the rule kept here), and deny. Why it asks is the tool call's content. Only an option offered
+// can change Claude's permissions.
+import { randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
+
+const deny = { behavior: 'deny', message: '用户未批准此操作' };
+
+export function permissionRequest({ sessionId, toolName, input, context = {} }) {
+  // Identical suggestions would be two options that do the same thing.
+  const suggestions = [...new Map((context.suggestions ?? []).map(change => [JSON.stringify(change), change])).values()];
+  const options = [{ optionId: 'allow-once', name: '仅允许本次', kind: 'allow_once' },
+    ...suggestions.map((change, i) => ({ optionId: `suggestion-${i}`, name: describeChange(change, input), kind: 'allow_always' })),
+    { optionId: 'deny', name: '拒绝', kind: 'reject_once' }];
+  const params = { sessionId, options, toolCall: { toolCallId: context.toolUseID ?? randomUUID(), title: toolName, rawInput: input, status: 'pending',
+    ...(context.decisionReason ? { content: [{ type: 'content', content: { type: 'text', text: context.decisionReason } }] } : {}) } };
+  const answer = response => {
+    const { outcome, optionId } = response?.outcome ?? {};
+    if (outcome !== 'selected') return deny;
+    if (optionId === 'allow-once') return { behavior: 'allow', updatedInput: input };
+    const change = suggestions[/^suggestion-(\d+)$/.exec(optionId ?? '')?.[1]];
+    return change ? { behavior: 'allow', updatedInput: input, updatedPermissions: [change] } : deny;
+  };
+  return { params, answer };
+}
+
+// Two suggestions for the same tool are different grants; the name says what each allows, and where it is kept.
+const scopes = { session: '本会话', cliArg: '本进程', localSettings: '本项目 · 本机', projectSettings: '本项目 · 共享', userSettings: '所有项目' };
+const verbs = { allow: '允许', deny: '拒绝', ask: '每次询问' };
+const modes = { default: '默认', acceptEdits: '自动允许修改文件', bypassPermissions: '跳过所有审批', plan: '计划', dontAsk: '不询问' };
+const readTools = new Set(['Read', 'Glob', 'Grep']), editTools = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
+const shortPath = path => { const home = homedir(); return path === home || path.startsWith(`${home}/`) ? `~${path.slice(home.length)}` : path; };
+
+function describeRule({ toolName, ruleContent }, input, verb) {
+  if (ruleContent === undefined) return [`${verb}所有 ${toolName} 操作`];
+  if (toolName === 'Bash') {
+    if (ruleContent === input?.command) return [`${verb}这条完全相同的命令`];
+    if (ruleContent.endsWith(':*')) return [`${verb}以此开头的命令`, ruleContent.slice(0, -2)];
+    return [`${verb}命令`, ruleContent];
+  }
+  // Claude writes absolute paths in rules as `//abs/path`.
+  const path = shortPath(ruleContent.replace(/^\/\//, '/'));
+  if (readTools.has(toolName)) return [`${verb}读取`, path];
+  if (editTools.has(toolName)) return [`${verb}修改`, path];
+  if (toolName === 'WebFetch' && ruleContent.startsWith('domain:')) return [`${verb}访问`, ruleContent.slice(7)];
+  return [`${verb} ${toolName}`, ruleContent];
+}
+
+export function describeChange(change, input) {
+  const scope = scopes[change.destination] ?? change.destination ?? 'Agent 建议的范围', verb = verbs[change.behavior] ?? '允许';
+  const rules = change.rules ?? [], listed = rules.map(r => `${r.toolName}(${r.ruleContent ?? ''})`).join('、');
+  const directories = (change.directories ?? []).map(shortPath).join('、');
+  const [what, target] = (() => {
+    switch (change.type) {
+      case 'addRules': case 'replaceRules': {
+        const [added, target] = rules.length === 1 ? describeRule(rules[0], input, verb) : [`${verb} ${rules.length} 条规则`, listed];
+        // Replacing drops the scope's existing rules of this behavior.
+        return [change.type === 'replaceRules' ? `替换现有规则为：${added}` : added, target];
+      }
+      case 'removeRules': return [`移除${verb}规则`, listed];
+      case 'addDirectories': return ['允许访问目录', directories];
+      case 'removeDirectories': return ['移除目录', directories];
+      case 'setMode': return [`切换为「${modes[change.mode] ?? change.mode}」模式`];
+      default: return ['应用 Agent 建议的权限调整'];
+    }
+  })();
+  return `${what}${target ? ` ${target}` : ''}（${scope}）`;
+}

package/agent/questions.mjs

@@ -0,0 +1,39 @@
+// What Claude asks the user, as ACP forms in plain JSON Schema: its own questions (AskUserQuestion) and those of the MCP
+// servers it runs (a form, or a link to open).
+import { randomUUID } from 'node:crypto';
+
+// The choice that says the answer is the one written beside it: ACP forms carry no rule that one of two fields be filled,
+// so the question stays required and this is one of its choices.
+export const OTHER = 'coda:other';
+
+export function questionForm({ sessionId, toolCallId, input }) {
+  const questions = Array.isArray(input?.questions) ? input.questions : [];
+  const properties = {};
+  questions.forEach((q, i) => {
+    const choices = [...(q.options ?? []).map(o => ({ const: o.label, title: o.label + (o.description ? ` — ${o.description}` : '') })),
+      { const: OTHER, title: '其他（写在下面）' }];
+    properties[`q${i}`] = { title: q.question, description: q.header ?? '', ...(q.multiSelect
+      ? { type: 'array', items: { anyOf: choices }, minItems: 1 } : { type: 'string', oneOf: choices }) };
+    properties[`q${i}_other`] = { type: 'string', title: '其他' };
+  });
+  const params = { sessionId, ...(toolCallId ? { toolCallId } : {}), mode: 'form', message: 'Claude 需要你的回答',
+    requestedSchema: { type: 'object', properties, required: questions.map((_, i) => `q${i}`) } };
+  const answer = response => {
+    if (response?.action !== 'accept') return { behavior: 'deny', message: '用户取消了问答' };
+    const content = response.content ?? {};
+    return { behavior: 'allow', updatedInput: { ...input, answers: Object.fromEntries(questions.map((q, i) => {
+      const other = String(content[`q${i}_other`] ?? '').trim() || '其他', pick = value => value === OTHER ? other : value;
+      const value = content[`q${i}`];
+      return [q.question, Array.isArray(value) ? value.map(pick).join(', ') : pick(value)];
+    })) } };
+  };
+  return { params, answer };
+}
+
+// An MCP server's request (SDK onElicitation): its form as it is, or its link with nothing to fill in.
+export function elicitationForm({ sessionId, request }) {
+  if (request.mode === 'url') return { params: { sessionId, mode: 'url', message: request.message ?? '', url: request.url,
+    elicitationId: request.elicitationId ?? randomUUID() }, answer: response => ({ action: response?.action ?? 'cancel' }) };
+  return { params: { sessionId, mode: 'form', message: request.message ?? '', requestedSchema: request.requestedSchema ?? { type: 'object', properties: {} } },
+    answer: response => ['accept', 'decline', 'cancel'].includes(response?.action) ? response : { action: 'cancel' } };
+}

package/agent/session.mjs

@@ -0,0 +1,408 @@
+// One Claude Code session through its SDK (one `query` per process), as an ACP agent with Coda's waits
+// (docs/agent-protocol.md). Coda's prompts go into the query's input; a prompt is answered by the native result that names
+// its input. What Claude says, its tools and their results, its settings, its title and its usage become session updates;
+// what it keeps going beside a turn, waits (waits.mjs); what it asks, permission requests and forms, withdrawn as the SDK
+// withdraws them. A turn Claude begins on its own is told by what it handles. The plan windows it reports go to the file
+// the plugin's「Claude」panel reads (limits.json in CODA_PLUGIN_STATE, limits.mjs), not to Coda's session.
+import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { realpath, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { agent, PROTOCOL_VERSION, RequestError } from '@agentclientprotocol/sdk';
+import { ClaudeSessionLimits, accountHash } from './limits.mjs';
+import { sdkEnvironment } from './auth.mjs';
+import { SessionTitle } from './titles.mjs';
+import { MODEL_EFFORT, MODES, claudeModels, configOptions, reportedModel } from './models.mjs';
+import { permissionRequest } from './permissions.mjs';
+import { elicitationForm, questionForm } from './questions.mjs';
+import { ClaudeWaits } from './waits.mjs';
+
+// The Claude Agent SDK this entry runs, as the handshake's `agentInfo` names it (Coda's protocol「Agent 版本」).
+const SDK = (() => {
+  try { return JSON.parse(readFileSync(new URL('./package.json', import.meta.resolve('@anthropic-ai/claude-agent-sdk')), 'utf8')).version; }
+  catch { return null; }
+})();
+
+// Coda's session instructions (docs/agent-protocol.md「会话指令」), ACP's `systemPrompt`: its text, '' when there is none. Only
+// text appended to the agent's own is understood; anything else is refused before a session opens.
+export function sessionInstructions(systemPrompt) {
+  if (systemPrompt === undefined || systemPrompt === null) return '';
+  if (systemPrompt.mode !== 'append') throw new RequestError(-32602, '会话指令只支持 append 模式');
+  const { content } = systemPrompt;
+  if (!Array.isArray(content) || content.some(block => block?.type !== 'text' || typeof block.text !== 'string')) throw new RequestError(-32602, '会话指令只接受文本块');
+  return content.map(block => block.text).join('\n\n');
+}
+const text = content => typeof content === 'string' ? content : Array.isArray(content) ? content.filter(b => b.type === 'text').map(b => b.text).join('\n') : '';
+const interrupted = m => ['interrupt', 'cancelled'].includes(m.stop_reason) || ['aborted_streaming', 'aborted_tools'].includes(m.terminal_reason);
+const errorText = m => (m.errors?.length ? m.errors : [m.result || m.subtype]).join('\n');
+const failure = (message, code = -32603) => new RequestError(code, message);
+const denied = { behavior: 'deny', message: 'Coda 没有在请求结束前给出审批' };
+// A child session's output that comes before its task, kept until the task names that session: all of it, since what streamed
+// counts as said, a message's streamed pieces as one.
+const CHUNKS = new Set(['agent_message_chunk', 'agent_thought_chunk']);
+
+class InputStream {
+  queue = []; wake = null; ended = false;
+  push(message) { this.queue.push(message); this.wake?.(); }
+  close() { this.ended = true; this.wake?.(); }
+  async *[Symbol.asyncIterator]() {
+    while (!this.ended) {
+      if (this.queue.length) yield this.queue.shift();
+      else await new Promise(resolve => { this.wake = resolve; });
+    }
+  }
+}
+
+export class ClaudeSession {
+  // `env`: what the SDK's process is started with; `onEnded`: the query ended without being closed.
+  constructor({ sdk, env = process.env, environment = sdkEnvironment, initializationTimeoutMs = 60_000, onEnded = () => {} }) {
+    Object.assign(this, { sdk, env, environment, initializationTimeoutMs, onEnded });
+    this.phase = 'new'; this.input = new InputStream(); this.prompts = new Map(); this.withdrawals = new Set();
+    this.models = []; this.commands = []; this.terminal = null; this.current = { mode: 'default', model: undefined, effort: null };
+    // Streamed text by API message, so that the complete message adds only what was not streamed; tool calls said.
+    this.streams = new Map(); this.streamed = new Map(); this.tools = new Set(); this.children = new Set(); this.early = new Map(); this.compaction = null;
+    this.waits = new ClaudeWaits({ say: (params, sessionId = this.sessionId) => this.notify('_coda/wait', { sessionId, ...params }),
+      going: () => this.prompts.size > 0 || this.waits.handling, registered: sessionId => this.registered(sessionId) });
+  }
+  connect(stream) {
+    this.connection = agent({ name: 'coda-claude' })
+      .onRequest('initialize', () => ({ protocolVersion: PROTOCOL_VERSION, agentInfo: SDK ? { name: 'claude-agent-sdk', version: SDK } : { name: 'coda-claude', version: '1' },
+        agentCapabilities: { loadSession: true, sessionCapabilities: { additionalDirectories: {}, systemPrompt: {} }, _meta: { coda: { waits: {} } } } }))
+      // The SDK's own reading of these drops what its schema does not name, `systemPrompt` among them: they are read as sent.
+      .onRequest('session/new', params => params ?? {}, ({ params }) => this.open(params))
+      .onRequest('session/load', params => params ?? {}, ({ params }) => this.open(params, params.sessionId))
+      .onRequest('session/set_config_option', ({ params }) => this.configure(params.configId, params.value))
+      .onRequest('session/set_mode', async ({ params }) => { await this.configure('mode', params.modeId); return {}; })
+      .onRequest('session/prompt', ({ params }) => this.prompt(params))
+      .onNotification('session/cancel', ({ params }) => { if (params.sessionId === this.sessionId) void this.query?.interrupt().catch(() => {}); })
+      .onRequest('_coda/wait/stop', params => params, ({ params }) => this.stopWait(params))
+      .connect(stream);
+    this.client = this.connection.client;
+    return this.connection;
+  }
+  notify(method, params) { void this.client?.notify(method, params).catch(() => {}); }
+  update(sessionId, update) {
+    // Coda takes a child session's updates once a wait has named it.
+    if (sessionId !== this.sessionId && !this.children.has(sessionId)) {
+      if (!this.early.has(sessionId)) this.early.set(sessionId, []);
+      const early = this.early.get(sessionId), last = early.at(-1);
+      if (CHUNKS.has(update.sessionUpdate) && last?.sessionUpdate === update.sessionUpdate && last.messageId !== undefined && last.messageId === update.messageId)
+        early[early.length - 1] = { ...last, content: { type: 'text', text: last.content.text + update.content.text } };
+      else early.push(update);
+      return;
+    }
+    this.notify('session/update', { sessionId, update });
+  }
+  registered(sessionId) {
+    this.children.add(sessionId);
+    for (const update of this.early.get(sessionId) ?? []) this.notify('session/update', { sessionId, update });
+    this.early.delete(sessionId);
+  }
+  options() { return configOptions(this.models, this.current); }
+
+  async open({ cwd, mcpServers = [], additionalDirectories = [], systemPrompt }, resume) {
+    if (this.phase !== 'new') throw failure('每个 Claude 进程只有一个会话', -32600);
+    const instructions = sessionInstructions(systemPrompt);
+    this.phase = 'starting';
+    try {
+      const dir = await realpath(cwd);
+      if (!(await stat(dir)).isDirectory()) throw failure('cwd 不是目录', -32602);
+      if (resume && !await this.sdk.getSessionInfo(resume, { dir })) throw failure('原生 Claude 会话不存在', -32002);
+      const environment = await this.environment(this.env);
+      if (this.phase !== 'starting') throw failure('Claude 会话在启动时已关闭', -32001);
+      this.sessionId = resume ?? randomUUID(); this.cwd = dir;
+      // Coda's servers are stdio ones; the SDK keys them by name.
+      const servers = Object.fromEntries(mcpServers.filter(server => typeof server.command === 'string').map(({ name, command, args = [], env = [] }) =>
+        [name, { command, args, ...(env.length ? { env: Object.fromEntries(env.map(variable => [variable.name, variable.value])) } : {}) }]));
+      this.query = this.sdk.query({ prompt: this.input, options: {
+        // Skipping every approval is a mode the user may switch to later; the SDK refuses it unless allowed at start.
+        permissionMode: 'default', allowDangerouslySkipPermissions: true, settingSources: ['user', 'project', 'local'],
+        // Coda's session instructions (what its clients render, what the project's plugins say) follow Claude Code's own.
+        systemPrompt: { type: 'preset', preset: 'claude_code', ...(instructions ? { append: instructions } : {}) },
+        // Sessions reach each other through Coda's send, which the user approves and both threads show. A native peer
+        // message would start a turn Coda cannot attribute. Continuing a native subagent is in-process and unaffected.
+        settings: { crossSessionInbound: 'refuse' },
+        includePartialMessages: true, forwardSubagentText: true, cwd: dir,
+        ...(Object.keys(servers).length ? { mcpServers: servers } : {}), ...(additionalDirectories.length ? { additionalDirectories } : {}),
+        ...(resume ? { resume } : { sessionId: this.sessionId }),
+        // Claude Code reports running and idle only when asked: idle is what ends a task's wait.
+        env: { ...environment, CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS: '1' },
+        // Stop supplies the complete list of scheduled wakeups. A CronCreate result alone cannot tell whether one was later
+        // deleted or fired.
+        hooks: { Stop: [{ hooks: [async input => {
+          if (input.session_id === this.sessionId && Array.isArray(input.session_crons)) this.waits.scheduled(input.session_crons.filter(cron =>
+            typeof cron?.id === 'string' && cron.id && typeof cron.schedule === 'string' && typeof cron.recurring === 'boolean').slice(0, 50));
+          return {};
+        }] }] },
+        canUseTool: (toolName, input, context) => this.permission(toolName, input, context),
+        onElicitation: (request, context) => this.elicitation(request, context),
+        stderr: data => process.stderr.write(data),
+      } });
+      this.pump = this.consume();
+      let timer;
+      const initialization = await Promise.race([this.query.initializationResult(),
+        this.pump.then(() => { throw failure('Claude 会话在初始化时结束', -32001); }),
+        new Promise((_, reject) => { timer = setTimeout(() => reject(failure('Claude 初始化超时', -32001)), this.initializationTimeoutMs); })])
+        .finally(() => clearTimeout(timer));
+      if (this.phase !== 'starting') throw failure('Claude 会话在初始化时结束', -32001);
+      this.models = claudeModels(initialization.models); this.commands = initialization.commands ?? [];
+      // Who the session runs as, for the「Claude」panel (limits.mjs): the windows it reports are that account's, and
+      // only while the panel is of that account.
+      const email = initialization.account?.email;
+      this.account = typeof email === 'string' && email.trim() ? accountHash(email) : null;
+      if (this.env.CODA_PLUGIN_STATE) new ClaudeSessionLimits({ path: join(this.env.CODA_PLUGIN_STATE, 'limits.json') }).startedAs(this.account);
+      this.current.model = this.models[0]?.id;
+      this.phase = 'running';
+      return { ...(resume ? {} : { sessionId: this.sessionId }), configOptions: this.options() };
+    } catch (error) {
+      await this.close();
+      throw error instanceof RequestError ? error : failure(error?.message || 'Claude 会话启动失败');
+    }
+  }
+  async configure(configId, value) {
+    if (this.phase !== 'running') throw failure('Claude 会话未在运行', -32001);
+    if (configId === 'mode') {
+      if (!MODES.some(mode => mode.id === value)) throw failure('审批模式不可用', -32602);
+      await this.query.setPermissionMode(value); this.current.mode = value;
+    } else if (configId === 'model') {
+      if (!this.models.some(model => model.id === value)) throw failure('模型不可用', -32602);
+      await this.query.setModel(value); this.current.model = value;
+      // An effort chosen for the last model that this one does not have is no choice of it: the model's own goes on.
+      if (this.current.effort !== null && !this.models.find(model => model.id === value).efforts.includes(this.current.effort)) {
+        await this.query.applyFlagSettings({ effortLevel: null }); this.current.effort = null;
+      }
+    } else if (configId === 'effort') {
+      const effort = value === MODEL_EFFORT ? null : value;
+      if (effort !== null && !this.models.find(model => model.id === this.current.model)?.efforts.includes(effort)) throw failure('推理强度不适用于当前模型', -32602);
+      await this.query.applyFlagSettings({ effortLevel: effort }); this.current.effort = effort;
+    } else throw failure(`没有设置项 ${configId}`, -32602);
+    return { configOptions: this.options() };
+  }
+  // Answered when the native result that names this input arrives; accepting it into the input says nothing yet.
+  prompt({ prompt }) {
+    if (this.phase !== 'running') throw failure('Claude 会话未在运行', -32001);
+    const id = randomUUID(), content = prompt.filter(block => block.type === 'text').map(block => block.text).join('\n');
+    const answered = new Promise((resolve, reject) => this.prompts.set(id, { resolve, reject }));
+    this.input.push({ type: 'user', uuid: id, session_id: this.sessionId, parent_tool_use_id: null, message: { role: 'user', content } });
+    this.titleContext = ((this.titleContext ?? '') + '\n' + content + '\n').slice(-1000);
+    if (this.title) { this.title.append(this.titleContext); this.titleContext = ''; }
+    return answered;
+  }
+  async stopWait({ waitId }) {
+    const taskId = this.phase === 'running' ? this.waits.stop(waitId) : null;
+    if (taskId === null) throw failure('没有可以停止的等待项', -32602);
+    if (taskId) await this.query.stopTask(taskId);
+    return {};
+  }
+
+  permission(toolName, input, { signal, ...context }) {
+    if (!['starting', 'running'].includes(this.phase)) return Promise.resolve(denied);
+    this.begin();
+    // A subagent's request is in its session.
+    const sessionId = this.waits.childSession(context.agentID) ?? this.sessionId;
+    return toolName === 'AskUserQuestion'
+      ? this.ask('elicitation/create', questionForm({ sessionId, toolCallId: context.toolUseID, input }), signal, { behavior: 'deny', message: '问答已失效' })
+      : this.ask('session/request_permission', permissionRequest({ sessionId, toolName, input, context }), signal, denied);
+  }
+  elicitation(request, { signal }) {
+    if (!['starting', 'running'].includes(this.phase)) return Promise.resolve({ action: 'cancel' });
+    this.begin();
+    return this.ask('elicitation/create', elicitationForm({ sessionId: this.sessionId, request }), signal, { action: 'cancel' });
+  }
+  // Asked of Coda until it answers; withdrawn (`$/cancel_request`) once the SDK no longer waits for the answer.
+  async ask(method, { params, answer }, signal, fallback) {
+    if (signal?.aborted) return fallback;
+    const withdrawn = new AbortController(), withdraw = () => withdrawn.abort();
+    signal?.addEventListener('abort', withdraw, { once: true });
+    this.withdrawals.add(withdrawn);
+    try {
+      const response = await Promise.race([this.client.request(method, params, { cancellationSignal: withdrawn.signal }),
+        new Promise(resolve => withdrawn.signal.addEventListener('abort', () => resolve(null), { once: true }))]);
+      return withdrawn.signal.aborted ? fallback : answer(response);
+    } catch { return fallback; } finally { signal?.removeEventListener('abort', withdraw); this.withdrawals.delete(withdrawn); }
+  }
+
+  async consume() {
+    let error;
+    try {
+      for await (const message of this.query) {
+        try { this.receive(message); }
+        catch (failed) { process.stderr.write(`Claude 消息处理失败：${failed.message}\n`); }
+      }
+    } catch (value) { if (this.phase !== 'closing') error = value; }
+    finally {
+      const intended = this.phase === 'closing';
+      this.phase = 'ended'; this.input.close();
+      for (const withdrawn of this.withdrawals) withdrawn.abort();
+      for (const { reject } of this.prompts.values()) reject(failure(error?.message ?? 'Claude 会话已结束'));
+      this.prompts.clear();
+      try { this.query.close(); } catch {}
+      if (!intended) this.onEnded(error);
+    }
+  }
+  receive(m) {
+    const parent = m.parent_tool_use_id ?? null;
+    this.begin(m.type === 'user' && !parent && m.origin ? { origin: m.origin, text: text(m.message?.content) } : {});
+    switch (m.type) {
+      case 'system': return this.system(m);
+      case 'stream_event': return this.stream(m.event, parent);
+      case 'assistant': return this.assistant(m, parent);
+      case 'user': return this.toolResults(m, parent);
+      case 'result': return this.result(m);
+      case 'rate_limit_event': if (this.env.CODA_PLUGIN_STATE) new ClaudeSessionLimits({ path: join(this.env.CODA_PLUGIN_STATE, 'limits.json') }).observe(m.rate_limit_info, this.account ?? null);
+    }
+  }
+  system(m) {
+    switch (m.subtype) {
+      case 'init': {
+        if (m.session_id !== this.sessionId) return;
+        this.terminal = m.terminal_slash_commands ?? [];
+        // Its effort is the one applied, the model's own included: what was chosen stays what it was.
+        this.current = { ...this.current, model: reportedModel(this.models, this.current.model, m.model), mode: m.permissionMode ?? this.current.mode };
+        if (!this.title) {
+          const sessionId = this.sessionId;
+          this.title = new SessionTitle({ sdk: this.sdk, query: this.query, cwd: this.cwd, sessionId, alive: () => ['starting', 'running'].includes(this.phase),
+            publish: title => this.update(sessionId, { sessionUpdate: 'session_info_update', title }) });
+          this.title.append(this.titleContext ?? ''); this.titleContext = '';
+          void this.title.refresh();
+        }
+        // Every native turn opens with an init. One no prompt of Coda's began, and no handling already holds, is Claude's own.
+        if (!this.prompts.size && !this.waits.handling) this.opening = m;
+        else this.announce(m);
+        return;
+      }
+      case 'commands_changed': this.commands = m.commands ?? []; return this.announceCommands();
+      case 'status': case 'compact_boundary': {
+        if (m.permissionMode && m.permissionMode !== this.current.mode) {
+          this.current.mode = m.permissionMode;
+          this.update(this.sessionId, { sessionUpdate: 'config_option_update', configOptions: this.options() });
+        }
+        if (m.status === 'compacting' && !this.compaction?.active) this.compaction = { id: m.uuid ?? randomUUID(), active: true };
+        if (m.status === 'compacting' || m.subtype === 'compact_boundary' || this.compaction?.active) {
+          this.compaction ??= { id: m.uuid ?? randomUUID(), active: false };
+          this.compaction.active = m.status === 'compacting';
+          this.update(this.sessionId, { sessionUpdate: 'compaction_update', compactionId: this.compaction.id,
+            status: this.compaction.active ? 'in_progress' : m.compact_result === 'failed' ? 'failed' : 'completed', error: m.compact_error ?? null });
+          if (!this.compaction.active) this.compaction = null;
+        }
+        return;
+      }
+      case 'local_command_output': {
+        const said = m.content ?? m.stdout;
+        if (typeof said === 'string') this.update(this.sessionId, { sessionUpdate: 'agent_message_chunk', messageId: m.uuid, content: { type: 'text', text: said } });
+        return;
+      }
+      case 'session_state_changed': if (m.state === 'idle') this.waits.settled(); return;
+      case 'task_started': return this.waits.started(m, { start: true });
+      case 'task_updated': {
+        if (m.patch?.is_backgrounded === true) this.waits.backgrounded(m.task_id);
+        if (m.patch?.description) this.waits.renamed(m.task_id, m.patch.description);
+        return this.waits.ended(m.task_id, m.patch?.status);
+      }
+      case 'task_notification': return this.waits.ended(m.task_id, m.status, { outputFile: m.output_file });
+      case 'background_tasks_changed': if (Array.isArray(m.tasks)) this.waits.snapshot(m.tasks);
+    }
+  }
+  // A turn Claude began on its own is told by what it handles, before anything said or asked in it; its opening message, when
+  // that comes first, may say what that is.
+  begin(opening) {
+    if (!this.opening) return;
+    const init = this.opening; this.opening = null;
+    this.waits.takeUp(opening);
+    this.announce(init);
+  }
+  // What a turn's init says: the settings the session runs with, and its commands.
+  announce(init) {
+    this.update(this.sessionId, { sessionUpdate: 'config_option_update', configOptions: this.options() });
+    this.announceCommands();
+  }
+  // Until the native init says which commands are the terminal's own, the list is not known.
+  announceCommands() {
+    if (this.terminal === null) return;
+    this.update(this.sessionId, { sessionUpdate: 'available_commands_update', availableCommands: this.commands.filter(c => !this.terminal.includes(c.name))
+      .map(c => ({ name: c.name, description: c.description ?? '', ...(c.argumentHint ? { input: { hint: c.argumentHint } } : {}) })) });
+  }
+  chunk(sessionId, type, messageId, said) {
+    if (!said) return;
+    this.update(sessionId, { sessionUpdate: type === 'text' ? 'agent_message_chunk' : 'agent_thought_chunk', ...(messageId ? { messageId } : {}),
+      content: { type: 'text', text: said } });
+  }
+  stream(event, parent) {
+    const owner = parent ?? 'root', sessionId = parent ?? this.sessionId;
+    if (event?.type === 'message_start') {
+      this.streams.set(owner, event.message.id);
+      this.streamed.set(event.message.id, new Map());
+      // Kept for the messages streaming now; a message whose complete form came long ago is not.
+      if (this.streamed.size > 64) this.streamed.delete(this.streamed.keys().next().value);
+      if (parent) this.waits.model(parent, event.message.model);
+      return;
+    }
+    const apiId = this.streams.get(owner), blocks = this.streamed.get(apiId);
+    if (!blocks) return;
+    if (event.type === 'content_block_start' && ['text', 'thinking'].includes(event.content_block?.type)) {
+      const block = { type: event.content_block.type, sent: 0, confirmed: false }, said = event.content_block.text ?? event.content_block.thinking ?? '';
+      blocks.set(event.index, block); block.sent += said.length; this.chunk(sessionId, block.type, apiId, said);
+    } else if (event.type === 'content_block_delta' && ['text_delta', 'thinking_delta'].includes(event.delta?.type)) {
+      const block = blocks.get(event.index), said = event.delta.text ?? event.delta.thinking ?? '';
+      if (!block) return;
+      block.sent += said.length; this.chunk(sessionId, block.type, apiId, said);
+    }
+  }
+  assistant(m, parent) {
+    const sessionId = parent ?? this.sessionId, apiId = m.message?.id, blocks = this.streamed.get(apiId);
+    if (parent) this.waits.model(parent, m.message?.model);
+    for (const block of m.message?.content ?? []) {
+      if (block.type === 'tool_use') {
+        this.tools.add(block.id);
+        this.update(sessionId, { sessionUpdate: 'tool_call', toolCallId: block.id, title: block.name, rawInput: block.input, status: 'in_progress' });
+      } else if (['text', 'thinking'].includes(block.type)) {
+        const said = block.text ?? block.thinking ?? '';
+        // One complete packet carries one block of the message: the first streamed one of its kind not yet confirmed.
+        const streamed = [...(blocks?.values() ?? [])].find(b => b.type === block.type && !b.confirmed);
+        if (streamed) streamed.confirmed = true;
+        this.chunk(sessionId, block.type, apiId, said.slice(streamed?.sent ?? 0));
+        if (!parent && block.type === 'text') this.title?.append(said);
+      }
+    }
+  }
+  toolResults(m, parent) {
+    for (const block of Array.isArray(m.message?.content) ? m.message.content : []) {
+      if (block.type !== 'tool_result' || !this.tools.has(block.tool_use_id)) continue;
+      const said = text(block.content);
+      this.update(parent ?? this.sessionId, { sessionUpdate: 'tool_call_update', toolCallId: block.tool_use_id, status: block.is_error ? 'failed' : 'completed',
+        rawOutput: m.tool_use_result ?? block.content, content: [{ type: 'content', content: { type: 'text', text: said } }] });
+      // Claude Code says where a command it put in the background writes in the launch's result.
+      const path = said.match(/Output is being written to: (\S+?\.output)\b/)?.[1];
+      if (path) this.waits.outputFile(block.tool_use_id, path);
+    }
+  }
+  result(m) {
+    const usage = m.usage ?? {}, windows = Object.values(m.modelUsage ?? {});
+    this.update(this.sessionId, { sessionUpdate: 'usage_update', used: (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0),
+      size: Math.max(0, ...windows.map(w => w.contextWindow ?? 0)), cost: { amount: m.total_cost_usd ?? 0, currency: 'USD' } });
+    const ids = m.user_message_uuids ?? (m.user_message_uuid ? [m.user_message_uuid] : []), id = ids.find(id => this.prompts.has(id));
+    const cancelled = interrupted(m), failed = !cancelled && (m.is_error || m.subtype !== 'success');
+    if (id) {
+      const prompt = this.prompts.get(id); this.prompts.delete(id);
+      // What ended before this turn ended was taken in by it.
+      this.waits.settled();
+      if (failed) prompt.reject(failure(errorText(m))); else prompt.resolve({ stopReason: cancelled ? 'cancelled' : 'end_turn' });
+    } else if (this.waits.handling) {
+      // A turn of Claude's own has no reply to fail: what went wrong is said in it.
+      if (failed) this.chunk(this.sessionId, 'text', m.uuid, errorText(m));
+      this.waits.finished();
+    } else if (failed && this.prompts.size) {
+      // A failure of the session itself names no input: none of those given can be said to have run.
+      for (const prompt of this.prompts.values()) prompt.reject(failure(errorText(m)));
+      this.prompts.clear();
+    }
+    void this.title?.refresh(!failed && !cancelled);
+  }
+  async close() {
+    if (this.phase === 'ended' || this.phase === 'closing') return this.pump;
+    this.phase = 'closing'; this.input.close();
+    for (const withdrawn of this.withdrawals) withdrawn.abort();
+    try { this.query?.close(); } catch {}
+    if (this.pump) await this.pump; else this.phase = 'ended';
+  }
+}

package/agent/titles.mjs

@@ -0,0 +1,36 @@
+// SDK headless sessions do not automatically generate the CLI's topic title.
+// Use the same native generator as the ACP adapter, without blocking the event
+// pump or asking the main conversation to produce extra output.
+export class SessionTitle {
+  context = ''; settled = false; pending = null; last = null;
+  constructor({ sdk, query, cwd, sessionId, publish, alive, onError = () => {} }) {
+    Object.assign(this, { sdk, query, cwd, sessionId, publish, alive, onError });
+  }
+  append(text) { if (!this.settled) this.context = (this.context + text).slice(-1000); }
+  refresh(generate = false) {
+    // Serialize reads/generation; a result arriving during the initial read
+    // must still get its chance to generate a title.
+    this.pending = (this.pending ?? Promise.resolve()).then(() => this.update(generate))
+      .catch(error => this.onError(error)).catch(() => {});
+    return this.pending;
+  }
+  async update(generate) {
+    if (!this.alive()) return;
+    const info = await this.sdk.getSessionInfo(this.sessionId, { dir: this.cwd });
+    let title = info?.customTitle;
+    if (!title && generate && !this.settled && this.context.trim().length >= 10 &&
+        typeof this.query.generateSessionTitle === 'function') {
+      title = await this.query.generateSessionTitle(this.context.trim(), { persist: false });
+      if (!this.alive()) return;
+      // A /rename completed while generation was in flight takes precedence.
+      const current = await this.sdk.getSessionInfo(this.sessionId, { dir: this.cwd });
+      if (current?.customTitle) title = current.customTitle;
+      else if (typeof title === 'string' && title.trim())
+        await this.sdk.renameSession(this.sessionId, title, { dir: this.cwd });
+    }
+    if (!this.alive() || typeof title !== 'string' || !title.trim()) return;
+    title = title.replace(/\s+/g, ' ').trim();
+    this.settled = true; this.context = '';
+    if (title !== this.last) { await this.publish(title); this.last = title; }
+  }
+}

package/agent/waits.mjs

@@ -0,0 +1,229 @@
+// What Claude Code keeps going beside a turn, told to Coda as waits of its own (docs/agent-protocol.md「_coda/wait」): its
+// background tasks and subagents as the SDK reports them, and the wakeups it scheduled as its Stop hook lists them. A
+// subagent's session is the tool call that launched it; continued (SendMessage), it is another run under the same session.
+// What a subagent launches (`parent_task_id`) is told in that subagent's session, once a wait has told Coda that session.
+// A task that ends while no turn goes will wake Claude for its result: until a turn takes it up, or the session says idle,
+// it is still waited on. A turn Claude begins on its own handles what woke it (`takeUp`): what its opening message names,
+// else the tasks that ended, else the one wakeup due, else a wait of the turn's own; what it handles ends with that turn.
+const FINAL = { completed: 'done', failed: 'failed', killed: 'cancelled', stopped: 'cancelled', ended: 'done' };
+const open = state => state === 'waiting' || state === 'handling';
+const cut = (value, limit) => typeof value === 'string' && value ? value.slice(0, limit) : undefined;
+
+export class ClaudeWaits {
+  // `say`: a wait's report, and its session when that is a subagent's; `going`: whether a turn goes; `registered`: a subagent's
+  // session is known.
+  constructor({ say, going = () => false, registered = () => {}, now = Date.now }) {
+    this.say = say; this.going = going; this.registered = registered; this.now = now;
+    this.tasks = new Map(); this.crons = new Map(); this.own = new Set(); this.turns = 0;
+    // Commands in the foreground, by task id: each is its own tool call, which the turn (or the subagent) blocks on.
+    this.foreground = new Map();
+    // What is known of a launching tool call before its task is: a subagent's model, a command's output file.
+    this.models = new Map(); this.outputs = new Map();
+  }
+  get handling() { return this.own.size > 0 || [...this.tasks.values(), ...this.crons.values()].some(w => w.state === 'handling'); }
+  report(wait, state, fields = {}) {
+    wait.state = state;
+    const params = { waitId: wait.waitId, state, ...Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined)) };
+    // Kept while the session it is in is not yet told (`named`).
+    if (wait.held) wait.held.push(params); else this.say(params, wait.sessionId);
+  }
+  // A task begun (`task_started`, `start`), or listed among those in the background (`listed`).
+  started(native, { start = false, listed = false } = {}) {
+    if (native.ambient || typeof native.task_id !== 'string' || !native.task_id) return;
+    // A command in the foreground is not waited on until it is put in the background (`backgrounded`). A subagent in the
+    // foreground still is: its session is that card's.
+    if (native.is_backgrounded === false && native.task_type !== 'local_agent' && !this.tasks.has(native.task_id)) {
+      this.foreground.set(native.task_id, native);
+      return;
+    }
+    const known = this.tasks.get(native.task_id);
+    if (known) {
+      if (listed) known.listed = true;
+      // A snapshot names no tool call and may come before its run's start, even after its end: that start says the launching
+      // call, and with it a subagent's session. A start of the run already known is that run's, never another.
+      const sameRun = native.run_id && known.runId ? native.run_id === known.runId : !known.toolUseId;
+      if (start && sameRun && !known.toolUseId && native.tool_use_id) {
+        const toolUseId = cut(native.tool_use_id, 200), subagent = known.kind === 'subagent';
+        Object.assign(known, { toolUseId, runId: known.runId ?? native.run_id }, subagent ? { childSessionId: toolUseId } : {});
+        if (open(known.state)) this.report(known, known.state, { childSessionId: subagent ? toolUseId : undefined, toolCallId: toolUseId,
+          outputFile: subagent ? undefined : this.outputs.get(toolUseId), model: subagent ? this.models.get(toolUseId) : undefined });
+        if (subagent && !known.held) this.named(known);
+        // An end held for its session is told now while a turn goes, which takes it in.
+        if (known.final !== undefined && known.state === 'waiting' && this.going()) { this.report(known, known.final); known.final = undefined; }
+        return;
+      }
+      // Only a start of another run under another call brings a subagent that ended back; snapshots and repeats cannot.
+      if (!start || sameRun || known.kind !== 'subagent' || (open(known.state) && known.final === undefined) || !native.tool_use_id || native.tool_use_id === known.toolUseId) return;
+      // Its last run ends before the next begins; one the turn going handles leaves it to a wait of the turn's own.
+      if (known.state === 'handling' && this.own.size === 0) this.hold();
+      if (known.final !== undefined) { this.report(known, known.final); known.final = undefined; }
+      known.run++; Object.assign(known, { waitId: `${known.taskId}#${known.run}`, toolUseId: native.tool_use_id, runId: native.run_id });
+      this.report(known, 'waiting', { kind: 'subagent', title: cut(native.description, 500) ?? '子 Agent', childSessionId: known.childSessionId,
+        stoppable: true, model: this.models.get(known.childSessionId) });
+      return;
+    }
+    const subagent = native.task_type === 'local_agent', toolUseId = cut(native.tool_use_id, 200);
+    const task = { taskId: native.task_id, waitId: native.task_id.slice(0, 200), run: 1, kind: subagent ? 'subagent' : 'task', toolUseId, runId: native.run_id,
+      listed: listed || native.is_backgrounded === true, parentTaskId: native.parent_task_id, ...(subagent ? { childSessionId: toolUseId ?? native.task_id.slice(0, 200) } : {}) };
+    if (task.parentTaskId) {
+      const parent = this.tasks.get(task.parentTaskId);
+      if (parent?.toolUseId && !parent.held) task.sessionId = parent.childSessionId; else task.held = [];
+    }
+    this.tasks.set(task.taskId, task);
+    this.report(task, 'waiting', { kind: task.kind, title: cut(native.description, 500) ?? (subagent ? '子 Agent' : '后台任务'), stoppable: true,
+      childSessionId: task.childSessionId, toolCallId: toolUseId, outputFile: this.outputs.get(toolUseId),
+      model: subagent ? this.models.get(task.childSessionId) : undefined });
+    if (subagent && !task.held) this.named(task);
+  }
+  // A subagent's session told to Coda: what it said there comes after, and what it launched is told there, held reports first.
+  named(subagent) {
+    this.registered(subagent.childSessionId);
+    if (!subagent.toolUseId) return;
+    for (const task of this.tasks.values()) {
+      if (!task.held || task.parentTaskId !== subagent.taskId) continue;
+      const held = task.held;
+      task.held = undefined; task.sessionId = subagent.childSessionId;
+      for (const params of held) this.say(params, task.sessionId);
+      if (task.kind === 'subagent') this.named(task);
+    }
+  }
+  // A command in the foreground put in the background: from now on it is waited on, as begun there.
+  backgrounded(taskId) {
+    const native = this.foreground.get(taskId);
+    if (!native) return;
+    this.foreground.delete(taskId);
+    this.started({ ...native, is_backgrounded: true }, { start: true });
+  }
+  renamed(taskId, description) {
+    const task = this.tasks.get(taskId);
+    if (task && open(task.state) && cut(description, 500)) this.report(task, task.state, { title: cut(description, 500) });
+  }
+  // A task's end (`status` as the SDK says it; `ended` when it left the list without one): told now while a turn goes, which
+  // takes in its result; otherwise once a turn has taken it up.
+  ended(taskId, status, { outputFile } = {}) {
+    this.foreground.delete(taskId);
+    const task = this.tasks.get(taskId), final = FINAL[status];
+    if (!task || !final || !open(task.state)) return;
+    if (task.final !== undefined) { if (status !== 'ended') task.final = final; return; }
+    const fields = { outputFile: cut(outputFile, 4096) };
+    // A subagent whose session is not yet known ends once it is (`started`), or as the turn or the session settles.
+    if (task.state === 'handling' || !this.going() || (task.kind === 'subagent' && !task.toolUseId)) {
+      Object.assign(task, { final, endedAt: this.now() });
+      if (fields.outputFile) this.report(task, task.state, fields);
+    } else this.report(task, final, fields);
+  }
+  snapshot(list) {
+    const live = new Set(list.map(native => native.task_id));
+    for (const task of this.tasks.values()) if (task.listed && !live.has(task.taskId)) this.ended(task.taskId, 'ended');
+    for (const native of list) { this.backgrounded(native.task_id); this.started(native, { listed: true }); }
+  }
+  // The Stop hook's list of the wakeups the session has, complete each time.
+  scheduled(list) {
+    const listed = new Set();
+    for (const native of list) {
+      listed.add(native.id);
+      if (this.crons.has(native.id)) continue;
+      const cron = { waitId: native.id.slice(0, 200), schedule: native.schedule, recurring: native.recurring, prompt: native.prompt, at: nextRun(native.schedule, this.now()) };
+      this.crons.set(native.id, cron);
+      this.report(cron, 'waiting', { kind: 'timer', title: cut(native.prompt, 100) ?? cut(native.schedule, 500), detail: cut(native.schedule, 4000),
+        recurring: native.recurring, stoppable: false, at: cron.at === null ? undefined : new Date(cron.at).toISOString() });
+    }
+    for (const [id, cron] of this.crons) {
+      if (listed.has(id) || !open(cron.state)) continue;
+      if (cron.state === 'handling') cron.final = 'done'; else this.report(cron, 'done');
+    }
+  }
+  // The tasks that ended since the last turn: taken in by the turn that ended now, or not to wake Claude now it is idle.
+  settled() {
+    for (const task of this.tasks.values()) if (task.final !== undefined && task.state === 'waiting') { this.report(task, task.final); task.final = undefined; }
+  }
+  // A turn Claude began on its own: what it handles. `origin`, `text`: its opening message's, when that came first.
+  takeUp({ origin, text } = {}) {
+    const pending = [...this.tasks.values()].filter(task => task.final !== undefined && task.state === 'waiting');
+    const crons = [...this.crons.values()].filter(cron => open(cron.state));
+    let handled = [];
+    if (origin?.kind === 'task-notification') handled = origin.subkind === 'scheduled-trigger' ? crons.filter(cron => cron.prompt && cron.prompt === text)
+      : [...this.tasks.values()].filter(task => origin.runId && task.runId === origin.runId && open(task.state));
+    if (!handled.length) handled = pending.sort((a, b) => a.endedAt - b.endedAt);
+    if (!handled.length) {
+      // Which came due is not told: the one due, or else the only one there is.
+      const due = crons.filter(cron => cron.at !== null && cron.at <= this.now() + 60_000);
+      if ((due.length || crons.length) === 1) handled = due.length ? due : crons;
+    }
+    if (handled.length) for (const wait of handled) this.report(wait, 'handling');
+    else this.hold();
+  }
+  hold() {
+    const own = { waitId: `turn-${++this.turns}` };
+    this.own.add(own);
+    this.report(own, 'handling', { kind: 'task', title: 'Claude 自主继续', stoppable: false });
+  }
+  // That turn's end: what it handled ended with it, a recurring wakeup waits for its next time.
+  finished() {
+    for (const task of this.tasks.values()) if (task.state === 'handling') { this.report(task, task.final ?? 'done'); task.final = undefined; }
+    for (const cron of this.crons.values()) {
+      if (cron.state !== 'handling') continue;
+      if (cron.final !== undefined || !cron.recurring) { this.report(cron, 'done'); continue; }
+      cron.at = nextRun(cron.schedule, this.now());
+      this.report(cron, 'waiting', { at: cron.at === null ? undefined : new Date(cron.at).toISOString() });
+    }
+    for (const own of this.own) this.report(own, 'done');
+    this.own.clear();
+  }
+  // A stop Coda asks of a wait: the task to stop when it still goes (null: none). One that ended and is yet to be taken in is
+  // not waited for any more: it ends now ('').
+  stop(waitId) {
+    const task = [...this.tasks.values()].find(task => task.waitId === waitId && open(task.state));
+    if (!task) return null;
+    if (task.final === undefined) return task.taskId;
+    if (task.state === 'waiting') { this.report(task, task.final); task.final = undefined; }
+    return '';
+  }
+  childSession(agentId) { return typeof agentId === 'string' ? this.tasks.get(agentId)?.childSessionId ?? null : null; }
+  // A subagent's actual model, from its own replies (which can come before its task).
+  model(toolUseId, model) {
+    if (typeof model !== 'string' || !model.trim() || model === '<synthetic>') return;
+    this.models.set(toolUseId, model);
+    const task = [...this.tasks.values()].find(task => task.childSessionId === toolUseId && open(task.state));
+    if (task && task.model !== model) { task.model = model; this.report(task, task.state, { model: cut(model, 200) }); }
+  }
+  // Where a command put in the background writes, as its launch said.
+  outputFile(toolUseId, path) {
+    this.outputs.set(toolUseId, path);
+    const task = [...this.tasks.values()].find(task => task.toolUseId === toolUseId && task.kind === 'task' && open(task.state));
+    if (task) this.report(task, task.state, { outputFile: cut(path, 4096) });
+  }
+}
+
+// The next minute after `from` a five-field cron schedule matches, in local time (as Claude Code schedules); null when it
+// cannot be read or never matches within five years.
+export function nextRun(schedule, from = Date.now()) {
+  const fields = typeof schedule === 'string' ? schedule.trim().split(/\s+/) : [];
+  if (fields.length !== 5) return null;
+  const [minutes, hours, days, months, weekdays] = fields.map((field, i) => values(field, ...[[0, 59], [0, 23], [1, 31], [1, 12], [0, 7]][i]));
+  if (![minutes, hours, days, months, weekdays].every(Boolean)) return null;
+  if (weekdays.has(7)) weekdays.add(0);
+  // Both day fields restricted: either matches.
+  const day = date => fields[2] === '*' ? fields[4] === '*' || weekdays.has(date.getDay())
+    : fields[4] === '*' ? days.has(date.getDate()) : days.has(date.getDate()) || weekdays.has(date.getDay());
+  const t = new Date(from); t.setSeconds(0, 0); t.setMinutes(t.getMinutes() + 1);
+  for (const limit = from + 5 * 366 * 86_400_000; t.getTime() < limit;) {
+    if (!months.has(t.getMonth() + 1)) { t.setMonth(t.getMonth() + 1, 1); t.setHours(0, 0, 0, 0); }
+    else if (!day(t)) { t.setDate(t.getDate() + 1); t.setHours(0, 0, 0, 0); }
+    else if (!hours.has(t.getHours())) t.setHours(t.getHours() + 1, 0, 0, 0);
+    else if (!minutes.has(t.getMinutes())) t.setMinutes(t.getMinutes() + 1, 0, 0);
+    else return t.getTime();
+  }
+  return null;
+}
+function values(field, min, max) {
+  const set = new Set();
+  for (const part of field.split(',')) {
+    const m = /^(?:(\*)|(\d+)(?:-(\d+))?)(?:\/(\d+))?$/.exec(part);
+    if (!m) return null;
+    const low = m[1] ? min : Number(m[2]), high = m[1] ? max : m[3] !== undefined ? Number(m[3]) : m[4] ? max : low, step = m[4] ? Number(m[4]) : 1;
+    if (low < min || high > max || low > high || step < 1) return null;
+    for (let v = low; v <= high; v += step) set.add(v);
+  }
+  return set;
+}

package/icons/README.md

@@ -0,0 +1,15 @@
+# Claude 品牌图形
+
+仅用于标识会话所用的服务，不作为 Coda 自身标志。商标归各自权利人所有。
+
+- `claude.svg`：取自 [Claude 官网](https://claude.com/) 导航字标中的独立花形路径，保留官方 `#D97757` 色和几何形状；供 Claude SDK 使用。
+
+提取日期：2026-09-19。SVG 是可审阅的源文件，PDF 是由 CairoSVG 转换的等比矢量资源，清单的 `icon` 指向 PDF。重新生成 PDF（开发工具，不是构建或运行依赖）：
+
+```sh
+uv run --with cairosvg python - <<'PY'
+import cairosvg
+for name in ['claude']:
+    cairosvg.svg2pdf(url=f'{name}.svg', write_to=f'{name}.pdf')
+PY
+```

package/icons/claude.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="125" height="125" viewBox="0 0 125 125">
+<path d="M54.375 118.75L56.125 111L58.125 101L59.75 93L61.25 83.125L62.125 79.875L62 79.625L61.375 79.75L53.875 90L42.5 105.375L33.5 114.875L31.375 115.75L27.625 113.875L28 110.375L30.125 107.375L42.5 91.5L50 81.625L54.875 76L54.75 75.25H54.5L21.5 96.75L15.625 97.5L13 95.125L13.375 91.25L14.625 90L24.5 83.125L49.125 69.375L49.5 68.125L49.125 67.5H47.875L43.75 67.25L29.75 66.875L17.625 66.375L5.75 65.75L2.75 65.125L0 61.375L0.25 59.5L2.75 57.875L6.375 58.125L14.25 58.75L26.125 59.5L34.75 60L47.5 61.375H49.5L49.75 60.5L49.125 60L48.625 59.5L36.25 51.25L23 42.5L16 37.375L12.25 34.75L10.375 32.375L9.625 27.125L13 23.375L17.625 23.75L18.75 24L23.375 27.625L33.25 35.25L46.25 44.875L48.125 46.375L49 45.875V45.5L48.125 44.125L41.125 31.375L33.625 18.375L30.25 13L29.375 9.75C29.0417 8.625 28.875 7.375 28.875 6L32.75 0.750006L34.875 0L40.125 0.750006L42.25 2.625L45.5 10L50.625 21.625L58.75 37.375L61.125 42.125L62.375 46.375L62.875 47.75H63.75V47L64.375 38L65.625 27.125L66.875 13.125L67.25 9.125L69.25 4.375L73.125 1.87501L76.125 3.25L78.625 6.875L78.25 9.125L76.875 18.75L73.875 33.875L72 44.125H73.125L74.375 42.75L79.5 36L88.125 25.25L91.875 21L96.375 16.25L99.25 14H104.625L108.5 19.875L106.75 26L101.25 33L96.625 38.875L90 47.75L86 54.875L86.375 55.375H87.25L102.125 52.125L110.25 50.75L119.75 49.125L124.125 51.125L124.625 53.125L122.875 57.375L112.625 59.875L100.625 62.25L82.75 66.5L82.5 66.625L82.75 67L90.75 67.75L94.25 68H102.75L118.5 69.125L122.625 71.875L125 75.125L124.625 77.75L118.25 80.875L109.75 78.875L89.75 74.125L83 72.5H82V73L87.75 78.625L98.125 88L111.25 100.125L111.875 103.125L110.25 105.625L108.5 105.375L97 96.625L92.5 92.75L82.5 84.375H81.875V85.25L84.125 88.625L96.375 107L97 112.625L96.125 114.375L92.875 115.5L89.5 114.875L82.25 104.875L74.875 93.5L68.875 83.375L68.25 83.875L64.625 121.625L63 123.5L59.25 125L56.125 122.625L54.375 118.75Z" fill="#D97757"></path>
+</svg>

package/package.json

@@ -1,7 +1,51 @@
 {
   "name": "@coda-console/claude",
-  "version": "0.0.0",
-  "description": "Reserved for the first Coda plugin release.",
+  "id": "claude",
+  "displayName": "Claude",
+  "description": "Claude SDK Agent：Coda 基于 Claude Agent SDK 写的 ACP 入口，一个进程一个 SDK 会话；资源页的「Claude」面板显示会话报告的额度，可从 Coda 登录。",
+  "version": "1.3.1",
+  "dependencies": {
+    "@agentclientprotocol/sdk": "1.4.0",
+    "@anthropic-ai/claude-agent-sdk": "0.3.296"
+  },
+  "contributes": {
+    "agents": [
+      {
+        "id": "claude-sdk",
+        "displayName": "Claude SDK",
+        "icon": {
+          "light": "icons/claude.pdf"
+        },
+        "command": "exec \"$CODA_NODE\" \"$CODA_PLUGIN_PATH/agent/entry.mjs\"",
+        "modes": {
+          "title": "审批模式",
+          "unset": "人工审批",
+          "auto": "auto",
+          "full": "bypassPermissions"
+        },
+        "skillsDir": ".claude/skills",
+        "configFiles": [
+          "${CLAUDE_CONFIG_DIR:-~/.claude}/settings.json",
+          ".claude/settings.json",
+          ".claude/settings.local.json"
+        ],
+        "setupHint": "请在运行机配置 Claude SDK 认证；若指定了 token 文件，请检查路径和权限。"
+      }
+    ],
+    "panels": [
+      {
+        "id": "limits",
+        "title": "Claude",
+        "command": "node \"$CODA_PLUGIN_PATH/scripts/panel.mjs\"",
+        "signIn": {
+          "command": "exec node \"$CODA_PLUGIN_PATH/scripts/login.mjs\"",
+          "installed": "node \"$CODA_PLUGIN_PATH/scripts/login.mjs\" --installed",
+          "input": "authorizationCode",
+          "note": "登录保存在这台机器上，供 Claude SDK 使用；额度在会话运行后出现。这台机器若已配置 OAuth token、API key 或云服务商，会话仍优先用那些配置。"
+        }
+      }
+    ]
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -10,5 +54,10 @@
   },
   "publishConfig": {
     "access": "public"
-  }
+  },
+  "files": [
+    "agent",
+    "scripts",
+    "icons"
+  ]
 }

package/scripts/login.mjs

@@ -0,0 +1,76 @@
+// The「Claude」panel's login (`signIn`): `claude auth login --claudeai` of the CLI that comes with the plugin's own Claude
+// SDK (the one its sessions run), never another on the PATH. Coda shows the authorization link this prints
+// and writes the code the page gave back to its input, once (docs/plugins.md「面板的登录」). Only the official link is
+// passed on, and only a code bound to it is handed to the CLI, which does the exchange, keeps and renews the credentials.
+// What the CLI says otherwise is not passed on: it may carry the code. `--installed` says whether that CLI is there.
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { stripVTControlCharacters } from 'node:util';
+
+// Resolved beside the SDK, as its query() resolves it.
+export function claudeBinary() {
+  const sdk = createRequire(createRequire(import.meta.url).resolve('@anthropic-ai/claude-agent-sdk'));
+  const platform = process.platform, arch = process.arch;
+  const musl = platform === 'linux' && !process.report.getReport().header.glibcVersionRuntime;
+  for (const suffix of platform === 'linux' ? (musl ? ['-musl', ''] : ['', '-musl']) : ['']) {
+    try { return sdk.resolve(`@anthropic-ai/claude-agent-sdk-${platform}-${arch}${suffix}/claude${platform === 'win32' ? '.exe' : ''}`); }
+    catch {}
+  }
+  return null;
+}
+// The official authorization link among whole lines of what the CLI printed, terminal hyperlinks included.
+export function authorization(output) {
+  const lines = stripVTControlCharacters(output.slice(0, output.lastIndexOf('\n') + 1));
+  for (const match of lines.matchAll(/https:\/\/[^\s]+/g)) {
+    try {
+      const url = new URL(match[0]);
+      if (((url.origin === 'https://claude.ai' && url.pathname === '/oauth/authorize') ||
+           (url.origin === 'https://claude.com' && url.pathname === '/cai/oauth/authorize')) &&
+          url.searchParams.get('state') && url.searchParams.get('code_challenge') && url.searchParams.get('response_type') === 'code') return url;
+    } catch {}
+  }
+  return null;
+}
+// The code the page gives is `<code>#<state>`: one for another login is not handed over.
+export const bound = (code, url) => /^[A-Za-z0-9_-]+#[A-Za-z0-9_-]+$/.test(code) && code.split('#')[1] === url.searchParams.get('state');
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const binary = claudeBinary();
+  if (process.argv[2] === '--installed') process.exit(binary ? 0 : 1);
+  if (!binary) { console.error('找不到 Claude SDK 自带的 CLI'); process.exit(1); }
+  const env = { ...process.env, BROWSER: '/usr/bin/true', NO_COLOR: '1' };
+  // auth login otherwise silently imports this token instead of opening a fresh browser login.
+  delete env.CLAUDE_CODE_OAUTH_REFRESH_TOKEN; delete env.CLAUDE_CODE_OAUTH_SCOPES;
+  const child = spawn(binary, ['auth', 'login', '--claudeai'], { env, stdio: ['pipe', 'pipe', 'pipe'] });
+  child.stdin.on('error', () => {});
+  let output = '', url = null, failed = null;
+  const heard = chunk => {
+    if (url) return;
+    output += chunk;
+    url = authorization(output);
+    if (url) console.log(url.href);
+  };
+  child.stdout.on('data', heard); child.stderr.on('data', heard);
+  // Coda writes the code once, ending it with a newline.
+  let typed = '';
+  process.stdin.setEncoding('utf8').on('data', chunk => {
+    typed += chunk;
+    const end = typed.indexOf('\n');
+    if (end < 0) return;
+    const code = typed.slice(0, end).trim();
+    process.stdin.pause();
+    if (url && bound(code, url)) return child.stdin.write(`${code}\n`);
+    failed = '授权码不对：要贴这次登录的网页给出的完整授权码，请重新登录。';
+    child.kill();
+  });
+  child.on('error', () => { failed ??= 'Claude CLI 没能启动'; });
+  // Coda ends the whole group; one ended alone takes its CLI along.
+  for (const signal of ['SIGTERM', 'SIGINT']) process.on(signal, () => { child.kill(); process.exit(1); });
+  child.on('close', code => {
+    if (code === 0 && !failed) process.exit(0);
+    console.error(failed ?? 'Claude 登录没有完成，请重新登录。');
+    process.exit(1);
+  });
+}

package/scripts/panel.mjs

@@ -0,0 +1,6 @@
+// The「Claude」panel's reading, printed once as `{ items }`, from what the sessions wrote into this plugin's state.
+import { join } from 'node:path';
+import { ClaudeSessionLimits } from '../agent/limits.mjs';
+import { panel } from './quota.mjs';
+
+console.log(JSON.stringify(panel(new ClaudeSessionLimits({ path: process.env.CODA_PLUGIN_STATE ? join(process.env.CODA_PLUGIN_STATE, 'limits.json') : null }))));

package/scripts/quota.mjs

@@ -0,0 +1,11 @@
+// What the「Claude」panel shows (docs/plugins.md「内置插件：Claude」): the plan windows this machine's Claude sessions last
+// reported (agent/limits.mjs). Nothing reported yet shows nothing; the panel is then offered under「添加资源」 for signing in.
+export function panel(limits) {
+  if (!limits.known()) return { items: [] };
+  const windows = limits.quota();
+  // The account the windows are of, compared across machines by Coda's group view.
+  return { items: [{ type: 'card', title: 'Claude SDK', ...(limits.account ? { identity: `claude:${limits.account}` } : {}), items: windows.length
+    ? windows.map(w => ({ type: 'meter', label: w.label, value: `剩余 ${w.remainingPercent}%`, fraction: w.remainingPercent / 100, time: w.resetsAt, timeLabel: '重置' }))
+    // Past its reset a window is not known, neither full nor empty: what was used since is not seen from here.
+    : [{ type: 'error', text: '额度记录已过期，会话再运行后更新' }] }] };
+}

package/README.md

@@ -1,3 +0,0 @@
-# @coda-console/claude
-
-Bootstrap placeholder. The usable release will be published by coda-console/coda-plugins.