@kingsoftcloud/agentkit-harness-ui 0.0.0-stage → 0.0.1

package/src/host/state/native-recovery.mjs

@@ -0,0 +1,187 @@
+const check = (value, message) => { if (!value) throw Error(message); };
+const counters = ['inputTokens', 'outputTokens', 'modelCalls', 'toolCalls', 'cost'];
+const optionalCounters = ['cachedInputTokens', 'reasoningTokens'];
+const validUsage = usage => usage && typeof usage === 'object' && !Array.isArray(usage)
+  && Object.keys(usage).every(key => [...counters, ...optionalCounters].includes(key))
+  && [...counters, ...optionalCounters.filter(key => key in usage)].every(key => typeof usage[key] === 'number'
+    && Number.isFinite(usage[key]) && usage[key] >= 0 && (key === 'cost' || Number.isSafeInteger(usage[key])));
+
+export function validateNativeRecoveryStatus(value, { agentId, sessionId, runId } = {}) {
+  check(value?.contract === 'agentkit.studio-native-recovery/v1' && value.agentId === agentId && value.sessionId === sessionId
+    && ['available', 'recovering', 'reconciliation_required', 'failed', 'closed'].includes(value.state)
+    && typeof value.canResume === 'boolean' && (!value.canResume || typeof value.runId === 'string' && value.runId.trim())
+    && (!runId || value.runId === runId), '恢复记录与原会话或运行不一致，请刷新核对。');
+  if (value.error != null) check(typeof value.error?.code === 'string' && /^[A-Za-z0-9_.:/-]{1,256}$/.test(value.error.code)
+    && typeof value.error.message === 'string' && value.error.message.length > 0 && value.error.message.length <= 512,
+  '运行错误记录无法识别，请刷新核对。');
+  if (value.outcome != null) check(['verified', 'unverified', 'partial', 'blocked', 'failed', 'budget_exhausted'].includes(value.outcome), '任务结果状态无法识别，请刷新核对。');
+  if (value.verificationRequired !== undefined) check(typeof value.verificationRequired === 'boolean', '任务验证要求无法识别，请刷新核对。');
+  if (value.canRetireResources !== undefined) check(typeof value.canRetireResources === 'boolean'
+    && (!value.canRetireResources || !value.managed && value.phase === 'interrupted'
+      && Number.isSafeInteger(value.resourceRetirementEventSeq) && value.resourceRetirementEventSeq >= 0),
+  '资源退役权限无法识别，请刷新核对。');
+  if(value.resourceRetirementReview!==undefined)check(value.resourceRetirementReview?.contract==='agentkit.resource-retirement-review/v1'
+    && typeof value.resourceRetirementReview.commandId==='string' && value.resourceRetirementReview.commandId.trim()
+    && value.resourceRetirementReview.commandId.length<=256 && value.resourceRetirementReview.resourceKind==='ephemeral-browser'
+    && value.resourceRetirementReview.eventSeq===value.resourceRetirementEventSeq,'资源退役记录与原运行不一致，请刷新核对。');
+  if (value.canReviewBackground !== undefined) check(typeof value.canReviewBackground === 'boolean'
+    && (!value.canReviewBackground || !value.managed && value.phase === 'interrupted'
+      && value.reason === 'effect_outcome_unknown' && Number.isSafeInteger(value.backgroundReviewEventSeq)
+      && value.backgroundReviewEventSeq >= 0), '后台操作核对权限无法识别，请刷新核对。');
+  if (value.backgroundInterruptionReview !== undefined) {
+    const review = value.backgroundInterruptionReview;
+    check(review?.contract === 'agentkit.background-interruption-review/v1' && review.confirmedStopped === true
+      && typeof review.commandId === 'string' && !!review.commandId.trim() && review.commandId.length <= 256
+      && review.eventSeq === value.backgroundReviewEventSeq && value.phase === 'interrupted'
+      && value.reason === 'effect_outcome_unknown', '后台操作处置记录无法识别，请刷新核对。');
+  }
+  if (value.capabilities != null) check(Array.isArray(value.capabilities.toolNames)
+    && value.capabilities.toolNames.every(name => typeof name === 'string' && name.length > 0 && name.length <= 256), '能力清单无法识别，请刷新核对。');
+  const receiptWait = value.receiptWait;
+  if (value.managed !== undefined) check(value.managed?.contract === 'agentkit.studio-managed-native-recovery/v1'
+    && value.managed.controlAuthority === 'server' && ['open', 'closed', 'pending'].includes(value.managed.owner)
+    && ['accepted', 'settled', 'discarded'].includes(value.managed.commandState)
+    && ['queued', 'running', 'idle'].includes(value.managed.executionState)
+    && typeof value.managed.commandId === 'string' && value.managed.commandId.trim() && value.managed.commandId.length <= 256
+    && typeof value.managed.retryAcceptedCommand === 'boolean'
+    && (!value.canResume || value.managed.retryAcceptedCommand) && value.canReconcile === false,
+  '托管运行的控制权限与原记录不一致，请刷新核对。');
+  const grant = value.managed?.executionGrant;
+  if (grant !== undefined) check(grant?.contract === 'agentkit.managed-native-execution-grants/v1'
+    && typeof grant.grantId === 'string' && grant.grantId === grant.grantId.trim() && grant.grantId.length > 0 && grant.grantId.length <= 512
+    && ['active', 'suspended', 'revoked', 'missing'].includes(grant.state)
+    && [grant.revision, grant.admissionRevision].every(revision => grant.state === 'missing' ? revision === null : Number.isSafeInteger(revision) && revision >= 1)
+    && (grant.attemptEpoch === null || Number.isSafeInteger(grant.attemptEpoch) && grant.attemptEpoch >= 1)
+    && (grant.expiresAt === null || typeof grant.expiresAt === 'string' && Number.isFinite(Date.parse(grant.expiresAt)))
+    && typeof grant.admissionAllowed === 'boolean' && typeof grant.qualified === 'boolean'
+    && (grant.blockedReason === null || ['not_found', 'scope_mismatch', 'revoked', 'attempt_epoch_mismatch', 'expired',
+      'clock_unverified', 'suspended', 'admission_paused'].some(reason => grant.blockedReason === `execution_grant_${reason}`))
+    && (!grant.blockedReason || !value.canResume && !value.managed.retryAcceptedCommand),
+  '执行授权与原托管运行不一致，请刷新核对。');
+  if (value.managed?.commandState === 'discarded') check(value.state === 'closed' && value.phase === 'discarded'
+    && !value.canResume && !value.managed.retryAcceptedCommand && value.managed.owner === 'closed'
+    && !grant?.qualified, '已丢弃的托管命令不能重新执行。');
+  if (receiptWait !== undefined) check(receiptWait?.contract === 'agentkit.native-a2a-receipt-wait/v1'
+    && value.phase === 'awaiting_reconciliation'
+    && ['operationKey', 'callId'].every(key => typeof receiptWait[key] === 'string' && receiptWait[key].trim()
+      && receiptWait[key] === value.reconciliation?.[key]), '回执等待与原运行不一致，请刷新核对。');
+  if (value.canReconcile !== undefined) check(typeof value.canReconcile === 'boolean'
+    && (!value.canReconcile || (value.state === 'reconciliation_required' && (!value.canResume || receiptWait)
+      || value.state === 'recovering' && !value.canResume)
+      && value.phase === 'awaiting_reconciliation' && typeof value.runId === 'string' && value.runId.trim()
+      && value.reconciliation?.contract === 'agentkit.tool-receipt-observation/v1'
+      && ['operationKey', 'callId'].every(key => typeof value.reconciliation[key] === 'string'
+        && value.reconciliation[key].trim() && value.reconciliation[key].length <= 256)),
+  '核对记录与原运行不一致，请刷新核对。');
+  if (value.canRepairWorkspace !== undefined) check(typeof value.canRepairWorkspace === 'boolean'
+    && (!value.canRepairWorkspace || !value.managed && value.canReconcile === true
+      && value.phase === 'awaiting_reconciliation'), '文件修复权限与原运行不一致，请刷新核对。');
+  if (value.a2aTasks !== undefined) check(Array.isArray(value.a2aTasks) && value.a2aTasks.length <= 10000
+    && value.a2aTasks.every(task => task?.runId === value.runId && ['runId', 'operationKey', 'callId']
+      .every(key => typeof task[key] === 'string' && task[key].trim() && task[key].length <= 256)),
+  '远端任务清单与原运行不一致，请刷新核对。');
+  const memory = value.cloudMemory;
+  if (memory != null) {
+    const id = text => typeof text === 'string' && text.trim().length > 0 && text.length <= 256;
+    const base = ['contract', 'sessionId', 'runId', 'state'];
+    const fields = [...base, 'resourceId', 'operationId', 'requestId', 'messageIds', 'phase', 'receiptRequestId', 'extraction', 'createdAt', 'completedAt'];
+    check(memory.contract === 'agentkit.studio-native-cloud-memory-status/v1' && memory.runId === value.runId
+      && memory.sessionId === sessionId && ['accepted', 'unconfirmed', 'outcome_unknown', 'unavailable'].includes(memory.state)
+      && Object.keys(memory).every(key => (memory.state === 'unavailable' ? base : fields).includes(key))
+      && (memory.state === 'unavailable' || id(memory.resourceId) && /^[0-9a-f]{64}$/.test(memory.operationId)
+        && id(memory.requestId) && Array.isArray(memory.messageIds) && memory.messageIds.length > 0 && memory.messageIds.length <= 20
+        && memory.messageIds.every(id) && memory.extraction === 'not_confirmed'
+        && memory.phase === (memory.state === 'unconfirmed' ? 'prepared' : 'finished')
+        && (memory.state === 'accepted' ? id(memory.receiptRequestId) : memory.receiptRequestId === null)
+        && Number.isSafeInteger(memory.createdAt) && memory.createdAt >= 0
+        && (memory.phase === 'prepared' ? memory.completedAt === null : Number.isSafeInteger(memory.completedAt) && memory.completedAt >= 0)),
+    '云记忆提交记录与原运行不一致，请刷新核对。');
+  }
+  const extraction = value.memoryExtraction;
+  if (extraction !== undefined) {
+    const id = text => typeof text === 'string' && text.trim().length > 0 && text.length <= 256;
+    check(extraction?.contract === 'agentkit.studio-native-memory-extraction/v1'
+      && extraction.agentId === agentId && extraction.sessionId === sessionId
+      && (extraction.cursor === null || id(extraction.cursor))
+      && Array.isArray(extraction.jobs) && extraction.jobs.length <= 100
+      && extraction.jobs.every(job => id(job.jobId) && id(job.parentRunId)
+        && ['queued', 'running', 'success', 'no-op', 'error', 'aborted', 'superseded'].includes(job.status)
+        && (job.usage === null || validUsage(job.usage))
+        && (job.errorCode === null || id(job.errorCode))
+        && Number.isSafeInteger(job.createdAt) && job.createdAt >= 0
+        && Number.isSafeInteger(job.updatedAt) && job.updatedAt >= job.createdAt),
+    '自动记忆提炼记录与原会话不一致，请刷新核对。');
+  }
+  const accounting = value.accounting;
+  if (accounting != null) {
+    check(accounting.contract === 'agentkit.studio-native-usage/v1' && accounting.runId === value.runId
+      && Number.isSafeInteger(accounting.snapshotRevision) && accounting.snapshotRevision >= 0
+      && ['final', 'incomplete', 'complete'].every(key => typeof accounting[key] === 'boolean')
+      && accounting.complete === (accounting.final && !accounting.incomplete)
+      && [accounting.own, accounting.descendant, accounting.total].every(validUsage)
+      && [...counters, ...optionalCounters].every(key => (accounting.total[key] ?? 0)
+        === (accounting.own[key] ?? 0) + (accounting.descendant[key] ?? 0)), '运行用量与原记录不一致，请刷新核对。');
+  }
+  return value;
+}
+
+/** Reads never resume work. A lost response retains the original Run identity. */
+export function createNativeRecoveryState({ hostRemote, agentId, sessionId, newCommandId = () => globalThis.crypto.randomUUID() }) {
+  const identity = { agentId, sessionId }, lifetime = new AbortController(), listeners = new Set();
+  let disposed = false, state = { status: null, loading: false, sending: false, pending: null, error: '' };
+  const set = change => { if (!disposed) { state = { ...state, ...change }; for (const listener of listeners) listener(state); } };
+  const validate = (value, runId) => validateNativeRecoveryStatus(value, { agentId, sessionId, runId });
+
+  async function refresh() {
+    if (disposed || state.loading) return;
+    set({ loading: true });
+    try {
+      const status = validate(await hostRemote.nativeRecoveryStatus(identity, lifetime.signal));
+      set({ status, error: '' });
+    } catch { set({ error: '恢复状态读取失败，请刷新。' }); }
+    finally { set({ loading: false }); }
+  }
+  async function send() {
+    if (disposed || state.sending || !state.pending) return;
+    const pending = state.pending;
+    set({ sending: true, error: '' });
+    try {
+      const { repairWorkspace, reviewBackground, retireResources, ...request } = pending;
+      const operation = retireResources ? hostRemote.retireNativeResources : reviewBackground ? hostRemote.reviewNativeBackground : repairWorkspace ? hostRemote.repairNativeWorkspace
+        : pending.operationKey ? hostRemote.reconcileNativeTool : hostRemote.resumeNativeRun;
+      const status = validate(await operation(request, lifetime.signal), pending.runId);
+      set({ status, pending: null });
+      await refresh();
+    } catch { set({ error: '恢复请求尚未确认。可确认原运行的请求，请勿创建替代任务。' }); }
+    finally { set({ sending: false }); }
+  }
+  return { getSnapshot: () => state, subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+    refresh, retry: send,
+    resume() {
+      if (disposed || state.pending || !state.status?.canResume) return;
+      set({ pending: { ...identity, runId: state.status.runId } }); return send();
+    },
+    reconcile() {
+      if (disposed || state.pending || !state.status?.canReconcile) return;
+      set({ pending: { ...identity, runId: state.status.runId, operationKey: state.status.reconciliation.operationKey,
+        commandId: newCommandId() } }); return send();
+    },
+    repairWorkspace() {
+      if (disposed || state.pending || !state.status?.canRepairWorkspace) return;
+      set({ pending: { ...identity, runId: state.status.runId, operationKey: state.status.reconciliation.operationKey,
+        commandId: newCommandId(), repairWorkspace: true } }); return send();
+    },
+    reviewBackground() {
+      if (disposed || state.pending || !state.status?.canReviewBackground) return;
+      set({ pending: { ...identity, runId: state.status.runId,
+        commandId: state.status.backgroundInterruptionReview?.commandId ?? newCommandId(),
+        eventSeq: state.status.backgroundReviewEventSeq, confirmedStopped: true, reviewBackground: true } }); return send();
+    },
+    retireResources() {
+      if (disposed || state.pending || !state.status?.canRetireResources) return;
+      set({pending:{...identity,runId:state.status.runId,commandId:state.status.resourceRetirementReview?.commandId??newCommandId(),
+        eventSeq:state.status.resourceRetirementEventSeq,confirmedRetired:true,retireResources:true}});return send();
+    },
+    dispose() { disposed = true; lifetime.abort(); listeners.clear(); },
+  };
+}

package/src/host/state/native-runtime-route.mjs

@@ -0,0 +1,26 @@
+/** Runtime routing is resolved before choosing a transcript renderer. A failed
+ * lookup is not evidence that the conversation belongs to another runtime. */
+export function nativeRuntimeRouteInput(_session, openState, projection, boundPresetId) {
+  // Identity comes from the current Session's keyed projection subscription,
+  // not the manager's asynchronously batched catalog/list snapshot. Read state
+  // only establishes readiness; it cannot overwrite the live preset identity.
+  return { presetId: boundPresetId, ready: openState === 'open' && projection?.state === 'ready' };
+}
+
+export async function resolveNativeRuntimeRoute({ hostRemote, presetId, resolveAgentFromPreset, signal }) {
+  const first = await hostRemote.agents({ source: 'local', pageSize: 100 });
+  signal.throwIfAborted();
+  if (!Array.isArray(first?.items)) throw Error('智能体目录响应无效');
+  const items = [...first.items];
+  for (let page = 2; items.length < Number(first.total || 0); page++) {
+    const next = await hostRemote.agents({ source: 'local', pageSize: 100, page });
+    signal.throwIfAborted();
+    if (!next.items?.length) throw Error('智能体目录尚未完整读取');
+    items.push(...next.items);
+  }
+  const agentId = resolveAgentFromPreset(presetId, items);
+  if (!agentId) return { kind: 'other', agentId: null };
+  const agent = items.find(item => (item.metadata?.id ?? item.id) === agentId);
+  if (!agent) throw Error('当前会话的智能体配置暂不可用');
+  return agent.spec?.runtime?.type === 'harness' ? { kind: 'native', agentId } : { kind: 'other', agentId };
+}

package/src/host/state/native-session-stop.mjs

@@ -0,0 +1,40 @@
+/** Session cancellation is a Host control, independent of tool interaction UI.
+ * An acknowledgement means requested, never that an effect has stopped. */
+export function createNativeSessionStop({ sessionId, requestStop }) {
+  let live = true, observation, running = false, generation = 0, pending = false;
+  let phase = 'idle', error = null;
+  const listeners = new Set();
+  const owned = () => Boolean(observation?.sessionId === sessionId && observation.runId
+    && !observation.managed && observation.state === 'recovering' && running);
+  const eligible = () => owned() && observation.phase === 'awaiting_interaction';
+  const getSnapshot = () => ({ phase, error, visible: eligible() || owned() && phase !== 'idle',
+    canStop: typeof requestStop === 'function' && eligible() && !pending && phase !== 'requested' });
+  const emit = () => { const value = getSnapshot(); for (const listener of listeners) listener(value); };
+  return {
+    getSnapshot,
+    subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+    observe(status, transportRunning) {
+      if (!live) return;
+      if (observation?.runId !== status?.runId || !transportRunning || status?.state !== 'recovering') {
+        generation++; pending = false; phase = 'idle'; error = null;
+      }
+      observation = status; running = transportRunning === true; emit();
+    },
+    async request() {
+      if (!live || !getSnapshot().canStop || typeof requestStop !== 'function') return false;
+      const current = generation; pending = true; phase = 'requesting'; error = null; emit();
+      try {
+        // The adapter invokes the existing Session owner, not a tool decision,
+        // ledger mutation, resume operation, or a guessed Native Run command.
+        const result = await requestStop(sessionId);
+        if (!live || current !== generation) return false;
+        if (result?.ok !== true || result.value?.accepted !== true) throw Error('stop_unconfirmed');
+        phase = 'requested'; return true;
+      } catch {
+        if (live && current === generation) { phase = 'error'; error = '停止请求未确认，请重试。'; }
+        return false;
+      } finally { if (live && current === generation) { pending = false; emit(); } }
+    },
+    dispose() { live = false; generation++; listeners.clear(); },
+  };
+}

package/src/host/state/native-status-panel.mjs

@@ -0,0 +1,23 @@
+/** Host facts adapted to the independent status presentation. No execution capability. */
+export function nativeStatusPanelModel(status, children = [], commandObservations = []) {
+  const activity = status?.activity;
+  const admitted = activity?.contract === 'agentkit.native-activity-status/v1' && activity.runId === status?.runId;
+  const sourceGit = status?.workspaceStatus?.state === 'available' ? status.workspaceStatus.git : null;
+  const git = sourceGit && ['added', 'removed', 'dirtyFileCount'].every(key => Number.isSafeInteger(sourceGit[key]) && sourceGit[key] >= 0)
+    && (sourceGit.branchName === null || typeof sourceGit.branchName === 'string') && sourceGit.added + sourceGit.removed > 0
+    ? { ...sourceGit } : null;
+  const plan = admitted && activity.plan && Array.isArray(activity.plan.items) ? activity.plan : null;
+  const facts = commandObservations.filter(fact => fact?.contract === 'agentkit.command-output-status/v1'
+    && fact.agentId === status?.agentId && fact.sessionId === status?.sessionId && fact.runId === status?.runId
+    && ['starting', 'running', 'completed', 'failed', 'canceled', 'timed_out', 'output_limit', 'unknown', 'unavailable'].includes(fact.status));
+  const terminals = admitted && Array.isArray(activity.terminals) ? activity.terminals.map(terminal => {
+    const observed = facts.find(fact => fact.taskId === terminal.id);
+    return observed ? { ...terminal, state: observed.status,
+      ...(typeof observed.command === 'string' && observed.command ? { title: observed.command.slice(0, 512) } : {}) } : terminal;
+  }) : [];
+  const agents = children.filter(task => task && ['childRunId', 'sessionId', 'parentRunId', 'role', 'phase'].every(key => typeof task[key] === 'string' && task[key])).map(task => ({ runId: task.childRunId, sessionId: task.sessionId, parentRunId: task.parentRunId,
+    role: task.role, title: task.goalPreview, phase: task.phase,
+    isRunning: task.canCancel === true, canCancel: false }));
+  return { git, plan, terminals, agents, isRunning: admitted && (activity.isRunning === true
+    || terminals.some(terminal => ['starting', 'running'].includes(terminal.state))) };
+}

package/src/host/state/native-task-read-model.mjs

@@ -0,0 +1,89 @@
+import { validateNativeRecoveryStatus } from './native-recovery.mjs';
+
+const id = value => typeof value === 'string' && value.trim() && value.length <= 256;
+const check = (value, message) => { if (!value) throw Error(message); };
+const loading = () => ({ phase: 'loading', observation: null, refreshing: false, error: null });
+
+/** One coherent presentation snapshot per Agent/Session. It never resumes work.
+ * SDK content supplies text deltas; only a complete authenticated read snapshot
+ * supplies Native outcomes, historical receipt states and child bindings.
+ */
+export function createNativeTaskReadModel({ hostRemote, agentId, sessionId }) {
+  check(id(agentId) && id(sessionId), '任务读取身份无效');
+  const identity = { agentId, sessionId }, listeners = new Set(), lifetime = new AbortController();
+  let state = loading(), active = null, timer = null, disposed = false, polling = false;
+  const publish = change => {
+    if (disposed) return;
+    state = { ...state, ...change };for (const listener of listeners) listener(state);
+  };
+  const readStatus = async () => validateNativeRecoveryStatus(
+    await hostRemote.nativeRecoveryStatus(identity, lifetime.signal), identity);
+  const readChildren = async () => {
+    const first = await hostRemote.nativeChildHistory({ ...identity, limit: 64 }, lifetime.signal);
+    check(first?.contract === 'agentkit.studio-native-child-history/v1' && first.sessionId === sessionId
+      && (first.runId === null || id(first.runId)) && /^[a-f0-9]{64}$/.test(first.inventoryDigest ?? '')
+      && Number.isSafeInteger(first.totalTasks) && first.totalTasks >= 0 && first.totalTasks <= 10000,
+    '子任务目录与原会话不一致');
+    const tasks = [], seen = new Set();let offset = 0, page = first;
+    while (true) {
+      check(page.contract === first.contract && page.sessionId === sessionId && page.runId === first.runId
+        && page.inventoryDigest === first.inventoryDigest && page.totalTasks === first.totalTasks
+        && page.offset === offset && Array.isArray(page.tasks) && page.tasks.length <= 64
+        && page.nextOffset === offset + page.tasks.length && page.nextOffset <= first.totalTasks
+        && page.complete === (page.nextOffset === first.totalTasks), '子任务目录读取期间发生变化');
+      for (const task of page.tasks) {
+        check(id(task?.childRunId) && id(task.parentRunId) && id(task.sessionId) && id(task.role)
+          && Number.isSafeInteger(task.snapshotRevision) && task.snapshotRevision >= 0 && !seen.has(task.childRunId),
+        '子任务目录包含无效或重复身份');
+        seen.add(task.childRunId);tasks.push(task);
+      }
+      if (page.complete) break;
+      check(page.nextOffset > offset, '子任务目录未取得进展');
+      offset = page.nextOffset;
+      page = await hostRemote.nativeChildHistory({ ...identity, limit: 64, offset,
+        inventoryDigest: first.inventoryDigest }, lifetime.signal);
+      lifetime.signal.throwIfAborted();
+    }
+    return { runId: first.runId, inventoryDigest: first.inventoryDigest, tasks };
+  };
+  const refresh = ({ fresh = false } = {}) => {
+    if (disposed) return Promise.resolve();
+    if (active) return fresh ? active.then(() => refresh()) : active;
+    publish({ refreshing: true, ...(state.observation ? {} : { phase: 'loading' }), error: null });
+    active = (async () => {
+      try {
+        for (let attempt = 0; attempt < 3; attempt++) {
+          const before = await readStatus();lifetime.signal.throwIfAborted();
+          const inventory = await readChildren();lifetime.signal.throwIfAborted();
+          const status = await readStatus();lifetime.signal.throwIfAborted();
+          // A new turn can be admitted between reads. Never combine its status
+          // with the prior turn's directory; read the current owner again.
+          if (status.runId !== before.runId || inventory.runId !== status.runId) continue;
+          publish({ phase: 'ready', observation: { status, children: inventory.tasks,
+            inventoryDigest: inventory.inventoryDigest }, error: null });
+          return;
+        }
+        throw Error('任务运行已变化，正在重新同步');
+      } catch {
+        if (!disposed) publish({ phase: state.observation ? 'ready' : 'error', error: '任务过程同步失败，请重试。' });
+      } finally { active = null;publish({ refreshing: false }); }
+    })();
+    return active;
+  };
+  return {
+    getSnapshot: () => state,
+    subscribe(listener) { listeners.add(listener);return () => listeners.delete(listener); },
+    refresh,
+    startPolling(intervalMs = () => 1500) {
+      check(!polling, '任务读取已在轮询');polling = true;
+      let stopped = false;
+      const poll = async () => {
+        await refresh();
+        if (!stopped && !disposed) timer = setTimeout(poll, Math.max(100, Number(intervalMs()) || 1500));
+      };
+      void poll();
+      return () => { stopped = true;polling = false;clearTimeout(timer);timer = null; };
+    },
+    dispose() { disposed = true;lifetime.abort();clearTimeout(timer);listeners.clear(); },
+  };
+}

package/src/host/state/task-links.mjs

@@ -0,0 +1,40 @@
+/** A Native execution root comes from the authenticated Host, not the model or
+ * the conversation shell's independently selected working directory. */
+export function nativeTaskWorkspaceRoot(status, { agentId, sessionId, fallback } = {}) {
+  const workspace = status?.workspace;
+  return status?.contract === 'agentkit.studio-native-recovery/v1' && !status.managed && status.agentId === agentId
+    && status.sessionId === sessionId && typeof status.runId === 'string' && status.runId
+    && workspace?.contract === 'agentkit.native-execution-workspace/v1'
+    && typeof workspace.workspaceId === 'string' && workspace.workspaceId
+    && typeof workspace.root === 'string' && workspace.root.length <= 32768
+    && !/[\u0000-\u001f]/.test(workspace.root) && /^(?:\/|[a-z]:[\\/])/i.test(workspace.root)
+    ? workspace.root : fallback;
+}
+
+/** Validate the original Markdown href before URL normalization can erase traversal. */
+export function taskWorkspaceFileTarget(href, workspaceRoot) {
+  if (typeof href !== 'string' || typeof workspaceRoot !== 'string' || !workspaceRoot) return null;
+  let value;
+  try { value = decodeURIComponent(href); } catch { return null; }
+  if (!value || /[\u0000-\u001f?#]/.test(value)) return null;
+  const position = value.match(/:(\d+)(?::(\d+))?$/);
+  if (position) {
+    if (![position[1], position[2]].filter(Boolean).every(v => Number.isSafeInteger(Number(v)) && Number(v) > 0)) return null;
+    value = value.slice(0, position.index);
+  }
+  value = value.replaceAll('\\', '/');
+  const base = workspaceRoot.replaceAll('\\', '/').replace(/\/+$/, '');
+  if (value.split('/').includes('..') || /^(?![a-z]:\/)[a-z][a-z\d+.-]*:/i.test(value) || value.startsWith('//')) return null;
+  const absolute = value.startsWith('/') || /^[a-z]:\//i.test(value);
+  if (absolute) {
+    const insensitive = /^[a-z]:\//i.test(base);
+    const input = insensitive ? value.toLowerCase() : value;
+    const prefix = (insensitive ? base.toLowerCase() : base) + '/';
+    if (!input.startsWith(prefix)) return null;
+  } else {
+    value = value.replace(/^(?:\.\/)+/, '');
+    if (!value || value.includes(':')) return null;
+    value = base + '/' + value;
+  }
+  return { path: value, ...(position ? { line: Number(position[1]), ...(position[2] ? { column: Number(position[2]) } : {}) } : {}) };
+}

package/src/host/task-timeline.mjs

@@ -0,0 +1,185 @@
+import { installNativeChildPane } from './native-child-pane.mjs';
+import { installNativeCommandPane } from './native-command-pane.mjs';
+import { createHarnessComponents } from '@kingsoftcloud/agentkit-harness-ui/react-binding';
+import { createMarkdownComponents, markdownStyles } from '@kingsoftcloud/agentkit-harness-ui/markdown';
+import { createStatusPanelComponents, statusPanelStyles } from '@kingsoftcloud/agentkit-harness-ui/status-panel';
+import { nativeStatusPanelModel } from './state/native-status-panel.mjs';
+import { nativeTaskWorkspaceRoot, taskWorkspaceFileTarget } from './state/task-links.mjs';
+import { resolveNativeRuntimeRoute, nativeRuntimeRouteInput } from './state/native-runtime-route.mjs';
+import { createNativeTaskReadModel } from './state/native-task-read-model.mjs';
+import { createSessionTaskProjector, nativeTaskState, nativeStatusForTurn, bindNativeSubagents, nativeHistoricalToolState } from './session-task-events.mjs';
+
+const labels = { result: '执行结果', thought: '思考', running: '执行中', thinking: '思考中…', ended: '本轮已结束', contextRunning: '正在压缩上下文', contextCompleted: '上下文已自动压缩',
+  contextFailed: '上下文压缩失败', contextInterrupted: '上下文压缩已中断', contextNoop: '上下文已是最新，无需压缩', interrupted: '任务已中断', recovered: '已恢复',
+  failed: '任务失败', completed: '已完成', cancelled: '已停止', blocked: '任务受阻', unverified: '已结束，结果未验证',
+  waiting: '等待确认或回执', paused: '已暂停', toolScheduled: '排队中', toolRunning: '执行中', toolCompleted: '已返回',
+  toolFailed: '执行失败', toolUncertain: '执行结果未知', toolNotDispatched: '未执行', jumpLatest: '回到最新',
+  readKind: '读取', readReading: '读取中', listKind: '列出文件', listSearching: '列出文件中', searchKind: '搜索', searchSearching: '搜索中',
+  searchListIn: '目录 {cwd}', searchFindQuery: '查找 {query}', searchList: '列出文件', searchFind: '查找',
+  copy: '复制', openFile: '打开文件', openTerminal: '查看终端输出', noOutput: '没有输出', inspect: '查看详情',
+  expandCommand: '展开命令', collapseCommand: '收起命令',
+  toolDetails: '工具详情', close: '关闭', state: '状态', arguments: '调用参数', noSettledResult: '尚无已确认的结果', appliedChanges: '实际文件变更',
+  diffTruncated: '差异预览已截断', diffUnavailable: '无可用差异预览', diffFilesOmitted: '个文件预览已省略', plan: '计划',
+  writePending: '请求写入', editPending: '请求修改',
+  subagent: '子智能体', openSubagent: '在右侧打开', childSyncing: '同步中', childOmitted: '当前显示过程窗口，较早内容或较长字段已省略。',
+  toolPreparing: '正在生成工具参数', previewStopped: '工具参数生成已中断' };
+
+/** Only the transport adapter and runtime controls belong to Studio. */
+export function installTaskTimeline(ctx, { ui, hostRemote, resolveAgentFromPreset }) {
+  if (typeof resolveAgentFromPreset !== 'function') throw TypeError('The host preset-to-Agent resolver is required');
+  const { React, ReactDOM } = ui;
+  const { createElement: h, useMemo, useEffect, useLayoutEffect, useState, useRef } = React;
+  const { HarnessTimeline } = createHarnessComponents(React);
+  const { ConversationStatusPanel } = createStatusPanelComponents(React, ReactDOM);
+  const { MarkdownResponse } = createMarkdownComponents(React, ReactDOM);
+  const commandPane = installNativeCommandPane(ctx, { React, hostRemote });
+  const childPane = installNativeChildPane(ctx, { React, hostRemote, labels, theme: 'system',
+    renderText: (text, { streaming, cwd, onOpenFile }) => h(MarkdownResponse, { streaming, theme: ctx.theme.getTheme().active.colorScheme,
+      onOpenExternalUrl: url => { if (['http:', 'https:'].includes(new URL(url).protocol)) window.open(url, '_blank', 'noopener,noreferrer'); },
+      onOpenFileLink: onOpenFile && (({ href }) => { const target = taskWorkspaceFileTarget(href, cwd); if (target) onOpenFile(target); }) }, text) });
+  const markdownLabels = { copyCode: '复制代码', copied: '已复制', wrapLines: '自动换行', languageLabel: '代码' };
+  function TaskView({ sessionId, useHarnessEvents, useSession, useSessions, useProjection, cwd, openFile, fallback, statusPanel }) {
+    const [variant, setVariant] = useState(() => {
+      try { const saved = localStorage.getItem('native.status-panel.variant'); return ['auto', 'mini', 'panel'].includes(saved) ? saved : 'auto'; }
+      catch { return 'auto'; }
+    });
+    const [theme, setTheme] = useState(() => ctx.theme.getTheme());
+    useEffect(() => ctx.on('theme/change', setTheme), []);
+    const eventWindow = useHarnessEvents(value => value);
+    const running = useSession(value => value.running);
+    const pending = useSession(value => value.pendingSubmissions);
+    const openState = useSession(value => value.openState);
+    const session = useSessions(value => value.byId[sessionId]);
+    const projection = useSessions(value => value.projectionsBySession?.[sessionId]);
+    const boundPresetId = useProjection('agentPreset');
+    const { presetId, ready: routeReady } = nativeRuntimeRouteInput(session, openState, projection, boundPresetId);
+    const routeKey = JSON.stringify([sessionId, presetId ?? null]);
+    const [route, setRoute] = useState({ key: routeKey, kind: 'loading', agentId: null });
+    const routeGeneration = useRef(0);
+    const [routeAttempt, setRouteAttempt] = useState(0);
+    const [projectionError, setProjectionError] = useState(null);
+    const [commandObservations, setCommandObservations] = useState([]);
+    const nativeAgent = route.key === routeKey && route.kind === 'native' ? route.agentId : null;
+    const observationKey = JSON.stringify([routeKey, nativeAgent, route.generation ?? 0]);
+    const readerRef = useRef(null), runningRef = useRef(running);runningRef.current = running;
+    const [readFrame, setReadFrame] = useState(null), [localError, setError] = useState(null);
+    const readSnapshot = readFrame?.key === observationKey ? readFrame.snapshot : null;
+    const observation = readSnapshot?.observation;
+    const status = observation?.status ?? null, childTasks = observation?.children ?? [];
+    const error = localError ?? readSnapshot?.error;
+    const projector = useMemo(() => createSessionTaskProjector({ sessionId }), [sessionId]);
+    const tasks = useMemo(() => projector.project(eventWindow), [projector, eventWindow]);
+    useEffect(() => {
+      let active = true;
+      setProjectionError(null);
+      if (typeof ctx.sessions.refreshProjections !== 'function') setProjectionError('宿主尚未提供会话运行时确认接口');
+      else void ctx.sessions.refreshProjections(sessionId).catch(failure => {
+        if (active) setProjectionError(failure.message || '无法读取会话运行时');
+      });
+      return () => { active = false; };
+    }, [sessionId, routeAttempt]);
+    useEffect(() => {
+      const controller = new AbortController();
+      const generation = ++routeGeneration.current;
+      setRoute({ key: routeKey, kind: 'loading', agentId: null, generation }); setError(null);
+      if (routeReady) void resolveNativeRuntimeRoute({ hostRemote, presetId, resolveAgentFromPreset, signal: controller.signal })
+        .then(next => { if (!controller.signal.aborted) setRoute({ ...next, key: routeKey, generation }); })
+        .catch(failure => { if (!controller.signal.aborted) setRoute({ key: routeKey, kind: 'error', agentId: null, generation,
+          error: failure.message || '无法读取当前会话的运行时' }); });
+      return () => controller.abort();
+    }, [routeKey, routeReady, routeAttempt]);
+    useEffect(() => {
+      if (!nativeAgent) return;
+      const reader = createNativeTaskReadModel({ hostRemote, agentId: nativeAgent, sessionId });
+      readerRef.current = reader;
+      const publish = snapshot => setReadFrame({ key: observationKey, snapshot });
+      publish(reader.getSnapshot());
+      const unsubscribe = reader.subscribe(publish);
+      const stop = reader.startPolling(() => runningRef.current ? 1500 : 3000);
+      return () => { unsubscribe();stop();reader.dispose();if (readerRef.current === reader) readerRef.current = null; };
+    }, [nativeAgent, sessionId, observationKey]);
+    useEffect(() => {
+      if (!nativeAgent || !observation) return;
+      childPane.bindHost({ agentId: nativeAgent, parentSessionId: sessionId }, { cwd, openFile, children: childTasks });
+      for (const task of childTasks) childPane.register({ agentId: nativeAgent, parentSessionId: sessionId,
+        parentRunId: task.parentRunId, runId: task.childRunId, sessionId: task.sessionId, role: task.role, title: task.goalPreview });
+    }, [childTasks, nativeAgent, sessionId, cwd, openFile, observation]);
+    useEffect(() => {
+      setCommandObservations([]);
+      if (nativeAgent) return commandPane.subscribe({ agentId: nativeAgent, sessionId }, setCommandObservations);
+    }, [nativeAgent, sessionId]);
+    const panelModel = useMemo(() => nativeStatusPanelModel(status, childTasks, commandObservations), [status, childTasks, commandObservations]);
+    useEffect(() => {
+      if (nativeAgent) for (const terminal of panelModel.terminals)
+        commandPane.register({ ...terminal, agentId: nativeAgent, sessionId });
+    }, [nativeAgent, sessionId, panelModel.terminals]);
+    const executionRoot = nativeTaskWorkspaceRoot(status, { agentId: nativeAgent, sessionId, fallback: cwd });
+    const openWorkspaceFile = path => {
+      const target = taskWorkspaceFileTarget(path, executionRoot);
+      if (!target) { setError('文件链接不在执行工作区或位置无效'); return; }
+      void Promise.resolve(openFile(target.path)).catch(failure => setError(failure.message || '无法打开文件'));
+    };
+    const panelVisible = nativeAgent && (panelModel.git || panelModel.plan || panelModel.agents.length || panelModel.terminals.length || panelModel.isRunning);
+    useLayoutEffect(() => {
+      // The presentation owns the summary seat while routing/loading too.
+      // Lack of polled data is not permission to paint the resident Todo dock.
+      const resident = route.key === routeKey && route.kind === 'other';
+      statusPanel?.setLayout(resident ? null : panelVisible ? variant : 'mini');
+      return () => statusPanel?.setLayout(null);
+    }, [statusPanel, panelVisible, variant, routeKey, route.key, route.kind]);
+    const openSubagent = target => {
+      try { childPane.open({ ...target, agentId: nativeAgent, parentSessionId: sessionId }); }
+      catch (failure) { setError(failure.message || '无法打开子会话'); }
+    };
+    const presented = tasks.map(task => ({ ...task, state: bindNativeSubagents(nativeHistoricalToolState(nativeStatusForTurn(status, task.turn)
+      ? nativeTaskState(task.state, status, running) : task.state, status, task.turn, sessionId), childTasks) }));
+    const resume = async () => {
+      const reader = readerRef.current;
+      try { setError(null); await hostRemote.resumeNativeRun({ agentId: nativeAgent, sessionId, runId: status.runId });await reader?.refresh({ fresh: true }); }
+      catch (failure) { setError(failure.message || '原任务尚未恢复'); }
+    };
+    if (projectionError || ['error', 'migration-required'].includes(projection?.state)) return h('div', { role: 'alert', 'data-testid': 'task-runtime-error' },
+      h('p', null, projectionError || (projection.state === 'migration-required' ? '会话元数据需要迁移，暂时无法确认运行时' : '无法读取会话运行时')),
+      h('button', { type: 'button', onClick: () => setRouteAttempt(value => value + 1) }, '重试加载'));
+    if (!routeReady || route.key !== routeKey || route.kind === 'loading') return h('div', { role: 'status', 'data-testid': 'task-runtime-loading' }, '正在加载任务过程…');
+    if (route.kind === 'error') return h('div', { role: 'alert', 'data-testid': 'task-runtime-error' },
+      h('p', null, route.error), h('button', { type: 'button', onClick: () => setRouteAttempt(value => value + 1) }, '重试加载'));
+    if (route.kind === 'other') return fallback;
+    if (!observation) return readSnapshot?.phase === 'error'
+      ? h('div', { role: 'alert', 'data-testid': 'task-observation-error' }, h('p', null, readSnapshot.error),
+        h('button', { type: 'button', onClick: () => void readerRef.current?.refresh() }, '重试加载任务过程'))
+      : h('div', { role: 'status', 'data-testid': 'task-observation-loading' }, '正在同步任务过程…');
+    return h('div', { 'data-testid': 'studio-task-timeline', style: { width: '100%', boxSizing: 'border-box', '--ui-font-size': 'var(--dsh-content-font-size, 14px)' } },
+      h('style', { 'data-harness-markdown': true }, markdownStyles),
+      statusPanel?.target ? ReactDOM.createPortal(h(React.Fragment, null,
+        h('style', { 'data-harness-status-panel': true }, statusPanelStyles),
+        h(ConversationStatusPanel, { model: panelModel, variant, theme: theme.active.colorScheme,
+          onVariantChange: mode => { setVariant(mode); try { localStorage.setItem('native.status-panel.variant', mode); } catch {} },
+          onOpenSubagent: openSubagent,
+          onOpenTerminal: terminal => commandPane.open({ ...terminal, agentId: nativeAgent, sessionId }),
+          onOpenSubagentDirectory: () => childPane.openDirectory({ agentId: nativeAgent, parentSessionId: sessionId }) })), statusPanel.target) : null,
+      ...presented.map(({ turn, state }) => h(HarnessTimeline, { key: turn,
+        state, labels, locale: 'zh-CN', showPlanDock: false, theme: theme.active.colorScheme,
+        workspaceRoot: executionRoot,
+        onOpenFile: ({ path }) => openWorkspaceFile(path),
+        onOpenSubagent: openSubagent,
+        onCopy: text => { void Promise.resolve().then(() => navigator.clipboard.writeText(text)).catch(() => setError('无法复制，请检查剪贴板权限')); },
+        renderText: (text, { streaming }) => h(MarkdownResponse, { streaming, theme: theme.active.colorScheme, scopeKey: sessionId + ':' + executionRoot,
+          labels: markdownLabels,
+          onCopyCode: text => navigator.clipboard.writeText(text),
+          onOpenExternalUrl: url => { if (['http:', 'https:'].includes(new URL(url).protocol)) window.open(url, '_blank', 'noopener,noreferrer'); },
+          onOpenFileLink: ({ href }) => openWorkspaceFile(href) }, text) })),
+      ...(pending ?? []).filter(item => item.placement === 'transcript').map(item => h('p', { key: item.requestId, 'aria-label': '待发送输入' }, item.text)),
+      error ? h('p', { role: 'alert' }, error) : null,
+      status?.canResume ? h('button', { type: 'button', onClick: () => void resume() }, '恢复原任务') : null);
+
+  }
+  ctx.slots.inject('conversation.chat.presentation', () => ctx.slots.register({
+    name: 'conversation.chat.presentation',
+    inject: sessionId => {
+      const binding = ctx.sessions.binding(sessionId);
+      if (!binding) throw Error('Task timeline session is unavailable');
+      return { hooks: { harnessEvents: binding.eventSource } };
+    },
+  }, TaskView));
+}