@arcfold/dsh-method-ui 0.0.0-stage → 0.4.0

package/src/client.mjs

@@ -0,0 +1,138 @@
+import { CollaborationView, CollaborationHero } from './CollaborationView.mjs';
+import { createBrowseScopeSource } from './browse-source.mjs';
+import { createOpportunitySource } from './opportunity-source.mjs';
+import { opportunitiesZh, opportunitiesEn } from './opportunity-locales.mjs';
+import { createImportSource } from './import-source.mjs';
+import { importsZh, importsEn } from './import-locales.mjs';
+import { createUnderstandingSource } from './understanding-source.mjs';
+import { understandingZh, understandingEn } from './understanding-locales.mjs';
+import { ModelSettings } from './ModelSettings.mjs';
+import { createModelSettingsSource } from './model-settings-source.mjs';
+import { modelsZh, modelsEn } from './model-settings-locales.mjs';
+import { createGoalSource } from './goal-source.mjs';
+import { goalZh, goalEn } from './goal-locales.mjs';
+import { createMethodSource } from './method-source.mjs';
+import { zh, en } from './locales.mjs';
+import { installTreeClient } from './tree-client.mjs';
+import { DesktopSetup } from './DesktopSetup.mjs';
+import { DesktopModels } from './DesktopModels.mjs';
+import { openDesktopWorkspace } from './desktop-workspace.mjs';
+export const inject = ['slots', 'connection', 'locale', 'fileUpload'];
+const NS = 'arcfold-methods';
+export async function apply(ctx) {
+  let desktop;
+  try { desktop = await ctx.connection.rpc.call('/api', 'arcfoldDesktop/status', { args: { request: {} } }); } catch {}
+  if (desktop?.ok === true && ['needs_setup', 'configured', 'activation_failed', 'interrupted', 'unavailable', 'ready'].includes(desktop.value?.state)) {
+    ctx.effect(() => { const style = document.createElement('style'); style.dataset.plugin = 'arcfold-desktop-setup';
+      style.textContent = '.arcfold-desktop-setup{max-width:42rem;margin:1rem auto;padding:1.5rem;line-height:1.6}.arcfold-desktop-setup code{overflow-wrap:anywhere}.arcfold-desktop-setup button{margin-top:1rem;padding:.5rem .9rem}.arcfold-desktop-setup label{display:block}';
+      document.head.append(style); return () => style.remove(); }, 'Arcfold Desktop setup style');
+    ctx.slots.inject('settings.models.footer', () => ctx.slots.register({ name: 'settings.models.footer', id: 'arcfold-deepseek-credential',
+      order: 11, inject: () => ({ rpc: ctx.connection.rpc }) }, DesktopModels));
+  }
+  if (desktop?.ok === true && ['needs_setup', 'configured', 'activation_failed', 'interrupted', 'unavailable'].includes(desktop.value?.state)) {
+    const props = { initial: desktop.value, rpc: ctx.connection.rpc,
+      openWorkspace: path => openDesktopWorkspace(ctx.get('workspaces'), ctx.get('uiWorkspace'), path) };
+    for (const name of ['settings.section', 'conversation.hero.options'])
+      ctx.slots.inject(name, () => ctx.slots.register({ name, id: 'arcfold-desktop-setup', order: 11, label: 'Arcfold 设置', inject: () => props }, DesktopSetup));
+    return;
+  }
+  const mode = await ctx.connection.rpc.call('/api', 'arcfoldMode/current', { args: {} });
+  if (mode?.ok !== true || typeof mode.value?.goalTreeV3 !== 'boolean') throw new Error('Arcfold 页面模式尚未确认，请重新连接。');
+  if (mode.value.goalTreeV3) {
+    ctx.slots.inject('conversation.input.dock', () => ctx.slots.register({ name: 'conversation.input.dock', id: 'goal', priority: -1 }, () => null));
+    return installTreeClient(ctx);
+  }
+  // Goals live in the Arcfold view. The official list-slot override removes
+  // only its composer control; ui-goal keeps rendering original goal history.
+  ctx.slots.inject('conversation.input.dock', () => ctx.slots.register({
+    name: 'conversation.input.dock', id: 'goal', priority: -1,
+  }, () => null));
+  const sources = new Set(), sessions = new Map();
+  const browseScope = createBrowseScopeSource(sources);
+  ctx.effect(() => ctx.locale.register(NS, { zh: { ...zh, ...goalZh, ...modelsZh, ...understandingZh, ...importsZh, ...opportunitiesZh }, en: { ...en, ...goalEn, ...modelsEn, ...understandingEn, ...importsEn, ...opportunitiesEn } }), 'Arcfold method UI copy');
+  ctx.effect(() => {
+    const style = document.createElement('style');
+    style.dataset.plugin = '@arcfold/dsh-method-ui';
+    style.textContent = typeof __ARCFOLD_METHOD_CSS__ === 'string' ? __ARCFOLD_METHOD_CSS__ : '';
+    document.head.append(style);
+    return () => style.remove();
+  }, 'Arcfold method UI style');
+  ctx.effect(() => () => { browseScope.dispose(); for (const source of sources) source.dispose(); sources.clear(); sessions.clear(); }, 'Arcfold method reads');
+  const modelSettings = createModelSettingsSource({ rpc: ctx.connection.rpc,
+    subscribeReset: listener => ctx.on('connection/reset', listener) });
+  sources.add(modelSettings);
+  const modelProps = {
+    hooks: { models: modelSettings },
+    onRefresh: () => modelSettings.refresh(),
+    onSaveLearning: request => modelSettings.saveLearning(request),
+    onStoreCredential: (provider, value) => modelSettings.storeCredential(provider, value),
+    onRemoveCredential: provider => modelSettings.removeCredential(provider),
+  };
+  ctx.slots.inject('settings.section', () => ctx.slots.register({
+    name: 'settings.section', id: 'arcfold-models', order: 11, locale: NS,
+    label: () => ctx.locale.bind(NS)('modelsTitle'),
+    inject: () => modelProps,
+  }, ModelSettings));
+  // Hero and tab share the same session-bound sources. Slot changes only
+  // unsubscribe; the source remains reusable until the plugin is unloaded.
+  const sessionProps = sessionId => {
+    if (sessions.has(sessionId)) return sessions.get(sessionId);
+    const viewScope = browseScope.getSnapshot().viewScope;
+    const source = createMethodSource({ rpc: ctx.connection.rpc, sessionId, viewScope,
+      subscribeReset: listener => ctx.on('connection/reset', listener) });
+    sources.add(source);
+    const goals = createGoalSource({ rpc: ctx.connection.rpc, sessionId, viewScope,
+      subscribeReset: listener => ctx.on('connection/reset', listener) });
+    sources.add(goals);
+    const understandings = createUnderstandingSource({ rpc: ctx.connection.rpc, sessionId, viewScope,
+      subscribeReset: listener => ctx.on('connection/reset', listener) });
+    sources.add(understandings);
+    const imports = createImportSource({ rpc: ctx.connection.rpc, fileUpload: ctx.fileUpload, sessionId, viewScope,
+      subscribeReset: listener => ctx.on('connection/reset', listener) });
+    sources.add(imports);
+    const opportunities = createOpportunitySource({ rpc: ctx.connection.rpc, sessionId, viewScope, subscribeReset: listener => ctx.on('connection/reset', listener) });
+    sources.add(opportunities);
+    const props = { ...modelProps, onModelsRefresh: modelProps.onRefresh, opportunitySessionId: sessionId, understandingSessionId: sessionId, importSessionId: sessionId, hooks: { models: modelSettings, browseScope, methods: source, goals, understandings, imports, opportunities },
+      onViewScopeChange: viewScope => browseScope.setViewScope(viewScope),
+      onOpportunityDetails: id => opportunities.details(id),
+      onOpportunityAct: (endpoint, request) => opportunities.act(endpoint, request),
+      onOpportunityRefresh: () => opportunities.refresh(),
+      onOpportunityPage: offset => opportunities.refresh(offset),
+      onImportUpload: (file, onProgress) => imports.upload(file, onProgress),
+      onImportPrepare: request => imports.prepare(request),
+      onImportDetails: request => imports.details(request),
+      onImportConfirm: request => imports.confirm(request),
+      onImportWithdraw: request => imports.withdraw(request),
+      onImportRefresh: () => imports.refresh(),
+      onImportPage: offset => imports.refresh(offset),
+      onDetails: (methodId, offset) => source.details(methodId, offset),
+      onDecide: request => source.decide(request),
+      onAcknowledge: id => source.acknowledge(id),
+      onRefresh: () => source.refresh(),
+      onPage: offset => source.refresh(offset),
+      onGoalDetails: id => goals.details(id), onGoalDecide: request => goals.decide(request),
+      onGoalDiscuss: request => goals.discuss(request), onGoalRefresh: () => goals.refresh(),
+      onGoalStopWork: request => goals.stopWork(request),
+      onGoalResumeWork: request => goals.resumeWork(request),
+      onGoalPage: offset => goals.refresh(offset),
+      onUnderstandingDetails: id => understandings.details(id),
+      onUnderstandingDecide: request => understandings.decide(request),
+      onUnderstandingCorrect: request => understandings.correct(request),
+      onUnderstandingRefresh: () => understandings.refresh(),
+      onUnderstandingPage: offset => understandings.refresh(offset),
+    };
+    sessions.set(sessionId, props);
+    return props;
+  };
+  ctx.slots.inject('conversation.view', () => ctx.slots.register({
+    name: 'conversation.view', id: 'arcfold', order: 20, locale: NS,
+    label: () => ctx.locale.bind(NS)('collaborationTitle'),
+    inject: sessionProps,
+  }, CollaborationView));
+  // The host renders hero.options only for a real blank session. Its normal
+  // view tabs are hidden then, so browsing never requires a model message.
+  ctx.slots.inject('conversation.hero.options', () => ctx.slots.register({
+    name: 'conversation.hero.options', id: 'arcfold', order: 20, locale: NS,
+    inject: sessionProps,
+  }, CollaborationHero));
+}

package/src/desktop-setup-host.mjs

@@ -0,0 +1,30 @@
+import { TypertRemoteService, RemoteError } from '@deepseek-ai/dsh-typert-protocol';
+const service = 'arcfoldDesktopWeb', namespace = 'arcfoldDesktop';
+
+export async function desktopRequest({ setup, connection }, method, request, signal, peer) {
+  if (!peer || peer !== connection.browserPeer || peer.principal?.kind !== 'owner' ||
+      peer.interactions !== 'answer' || peer.signal?.aborted !== false || signal?.aborted !== false)
+    throw new RemoteError('trusted_browser_required', '当前连接尚未认证。', {});
+  if (method === 'status') return setup?.status() ?? { state: 'not_desktop' };
+  if (method !== 'start' || !request || typeof request !== 'object' || Array.isArray(request) ||
+      Object.keys(request).join() !== 'confirmed' || request.confirmed !== true)
+    throw new RemoteError('invalid_desktop_setup', '请确认模型使用与费用后再继续。', {});
+  if (!setup?.start) throw new RemoteError('desktop_setup_unavailable', '当前环境无法进行 Desktop 设置。', {});
+  signal.throwIfAborted();
+  try { return await setup.start({ confirmed: true }); }
+  catch { throw new RemoteError('desktop_setup_failed', '设置未完成。请刷新并查看当前状态，避免重复创建数据。', {}); }
+}
+class DesktopWeb extends TypertRemoteService {
+  constructor(ctx) { super(ctx, service, { namespace }); }
+  dispatch(method, request) {
+    const { signal, peer } = this.ctx.invocation ?? {};
+    return desktopRequest({ setup: this.ctx.get('arcfoldDesktopSetup'), connection: this.ctx.connection }, method, request, signal, peer);
+  }
+  status(request) { return this.dispatch('status', request); }
+  start(request) { return this.dispatch('start', request); }
+}
+export const desktopInvocations = ['status', 'start'].map(method => ({
+  id: `@arcfold/dsh-method-ui#${namespace}/${method}`, service, namespace, method, invocation: { kind: 'direct' },
+  parameters: [{ name: 'request', wire: 'request', source: 'json', codec: { mode: 'src-json' } }], result: { mode: 'src-json' },
+}));
+export function installDesktopWeb(ctx) { return new DesktopWeb(ctx); }

package/src/desktop-workspace.mjs

@@ -0,0 +1,8 @@
+/** Use the host's native Workspace registration and navigation services. */
+export async function openDesktopWorkspace(workspaces, navigation, path) {
+  if (!workspaces || !navigation || typeof path !== 'string' || !path.startsWith('/'))
+    throw new Error('DSH 工作区服务尚未就绪。');
+  const workspace = await workspaces.create({ path });
+  if (!workspace?.workspaceId) throw new Error('无法确认新工作区。');
+  await navigation.openWorkspace(workspace.workspaceId, undefined, { agentPreset: 'arcfold-main' });
+}

package/src/goal-host.mjs

@@ -0,0 +1,133 @@
+import { currentMainAgent } from './main-session.mjs';
+import { browseScope } from './browse-scope.mjs';
+import { TypertRemoteService, RemoteError } from '@deepseek-ai/dsh-typert-protocol';
+
+const NAMESPACE = 'arcfoldGoals', SERVICE = 'arcfoldGoalWeb';
+const ENDPOINTS = ['list', 'details', 'decide', 'discuss', 'stopWork', 'resumeWork'];
+const invalid = message => { throw Object.assign(new Error(message), { code: 'invalid_goal_request' }); };
+function object(value, allowed, required = allowed) {
+  if (!value || typeof value !== 'object' || Array.isArray(value) ||
+      Object.keys(value).some(key => !allowed.includes(key)) || required.some(key => !Object.hasOwn(value, key)))
+    invalid('目标请求包含缺失或未允许的字段。');
+}
+function identity(value) {
+  if (typeof value !== 'string' || !value.trim() || value.length > 512 || value.includes('\0'))
+    invalid('请求身份不能为空或超长。');
+}
+function version(payload) {
+  if (!Number.isSafeInteger(payload.expectedRevision) || payload.expectedRevision < 1 ||
+      !Number.isSafeInteger(payload.definitionVersion) || payload.definitionVersion < 1)
+    invalid('操作必须绑定已查看的目标版本。');
+}
+function trusted(connection, signal, peer) {
+  if (!peer || peer !== connection.browserPeer || peer.principal?.kind !== 'owner' ||
+      peer.interactions !== 'answer' || peer.signal?.aborted !== false || signal?.aborted !== false)
+    throw Object.assign(new Error('此操作只接受当前已认证网页的请求。'), { code: 'trusted_browser_required' });
+}
+
+// The map coalesces only concurrent delivery of the same explicit submission.
+// Durable binding ownership, including unknown admission, belongs to GoalService.
+export function createGoalHandler({ goals, connection, agents, agentPresets, prompt, inflight = new Map() }) {
+  const assertMain = (sessionId, expected) => {
+    const agent = currentMainAgent({ agents, agentPresets }, sessionId);
+    if (!agent || expected && agent !== expected)
+      throw Object.assign(new Error('请打开当前的 Arcfold 主交流，再从这里发送目标讨论。'), { code: 'goal_main_session_required' });
+    return agent;
+  };
+  return async (endpoint, payload, signal, peer) => {
+    try {
+      trusted(connection, signal, peer);
+      let value;
+      if (endpoint === 'list') {
+        object(payload, ['sessionId', 'offset', 'limit', 'viewScope'], ['sessionId']); identity(payload.sessionId); browseScope(payload.viewScope);
+        if (payload.offset !== undefined && (!Number.isSafeInteger(payload.offset) || payload.offset < 0) ||
+            payload.limit !== undefined && (!Number.isSafeInteger(payload.limit) || payload.limit < 1 || payload.limit > 100))
+          invalid('目标分页参数不合法。');
+        value = { ...goals.list(payload), canDiscuss: currentMainAgent({ agents, agentPresets }, payload.sessionId) !== null };
+      } else if (endpoint === 'details') {
+        object(payload, ['sessionId', 'goalId', 'viewScope'], ['sessionId', 'goalId']); identity(payload.sessionId); identity(payload.goalId); browseScope(payload.viewScope);
+        value = goals.details(payload.goalId, { sessionId: payload.sessionId,
+          ...(payload.viewScope !== undefined ? { viewScope: payload.viewScope } : {}) });
+      } else if (endpoint === 'stopWork' || endpoint === 'resumeWork') {
+        object(payload, ['sessionId', 'workId', 'nativeGoalId', 'nativeRevision', 'requestId']);
+        for (const key of ['sessionId', 'workId', 'nativeGoalId', 'requestId']) identity(payload[key]);
+        if (!Number.isSafeInteger(payload.nativeRevision) || payload.nativeRevision < 1) invalid('执行版本不合法。');
+        const agent = assertMain(payload.sessionId);
+        value = goals.controlWork({ ...payload, agent, action: endpoint === 'stopWork' ? 'pause' : 'resume',
+          userIdentity: 'browser:' + peer.id });
+      } else if (endpoint === 'decide') {
+        object(payload, ['goalId', 'expectedRevision', 'definitionVersion', 'action', 'requestId', 'sessionId'],
+          ['goalId', 'expectedRevision', 'definitionVersion', 'action', 'requestId']);
+        if (payload.sessionId) assertMain(payload.sessionId);
+        identity(payload.goalId); identity(payload.requestId); version(payload);
+        if (!['pause', 'resume', 'close'].includes(payload.action)) invalid('目标决定必须是暂停、恢复或结束追踪。');
+        value = goals.decide({ ...payload, userIdentity: 'browser:' + peer.id });
+      } else if (endpoint === 'discuss') {
+        object(payload, ['sessionId', 'goalId', 'expectedRevision', 'definitionVersion', 'mode', 'text', 'requestId']);
+        identity(payload.sessionId); identity(payload.goalId); identity(payload.requestId); version(payload);
+        if (!['discuss', 'repair'].includes(payload.mode) || typeof payload.text !== 'string' ||
+            !payload.text.trim() || payload.text.length > 24000 || payload.text.includes('\0'))
+          invalid('请填写本次要发送的原话，长度不超过 24000 字。');
+        const agent = assertMain(payload.sessionId);
+        const content = [{ type: 'text', text: payload.text }];
+        const { text: _text, ...request } = payload;
+        const bound = goals.bindDiscussion({ ...request, content, userIdentity: 'browser:' + peer.id });
+        const key = bound.binding.id;
+        // A repeated request is validated by business before joining the in-flight call.
+        if (inflight.has(key)) value = inflight.get(key);
+        else if (!bound.created) value = bound; // No retry of failed, unknown or crash-interrupted admission.
+        else {
+          let enteredPrompt = false;
+          const pending = Promise.resolve().then(async () => {
+            let state;
+            try {
+              trusted(connection, signal, peer);
+              assertMain(payload.sessionId, agent);
+              enteredPrompt = true;
+              const result = await prompt({ sessionId: payload.sessionId, requestId: payload.requestId,
+                mode: 'queue', content }, signal);
+              state = result?.accepted === true ? 'accepted' : 'unknown';
+            } catch { state = enteredPrompt ? 'unknown' : 'failed'; }
+            const binding = goals.recordDiscussionAdmission({ bindingId: key, state });
+            return { ...bound, binding };
+          });
+          inflight.set(key, pending);
+          // Do not start another call if the caller disconnects or recording fails.
+          value = pending.finally(() => { if (inflight.get(key) === pending) inflight.delete(key); });
+        }
+      } else throw Object.assign(new Error('不存在的目标操作。'), { code: 'goal_endpoint_not_found' });
+      return { ok: true, value: await value };
+    } catch (error) {
+      return { ok: false, error: { code: typeof error?.code === 'string' ? error.code : 'goal_request_failed',
+        message: error instanceof Error ? error.message : '目标操作未完成。', details: {} } };
+    }
+  };
+}
+
+class GoalWeb extends TypertRemoteService {
+  inflight = new Map();
+  constructor(ctx) { super(ctx, SERVICE, { namespace: NAMESPACE }); }
+  async dispatch(endpoint, request) {
+    const invocation = this.ctx.invocation;
+    // Access through this call-derived Context preserves the original Gateway invocation.
+    const controller = this.ctx.sessionController;
+    const result = await createGoalHandler({ goals: this.ctx.arcfoldGoals, connection: this.ctx.connection, agents: this.ctx.agents, agentPresets: this.ctx.agentPresets,
+      inflight: this.inflight, prompt: (payload, signal) => controller.prompt(payload, signal) })(
+      endpoint, request, invocation?.signal, invocation?.peer);
+    if (!result.ok) throw new RemoteError(result.error.code, result.error.message, result.error.details);
+    return result.value;
+  }
+  list(request) { return this.dispatch('list', request); }
+  details(request) { return this.dispatch('details', request); }
+  decide(request) { return this.dispatch('decide', request); }
+  discuss(request) { return this.dispatch('discuss', request); }
+  stopWork(request) { return this.dispatch('stopWork', request); }
+  resumeWork(request) { return this.dispatch('resumeWork', request); }
+}
+
+export const goalInvocations = ENDPOINTS.map(method => ({ id: `@arcfold/dsh-method-ui#${NAMESPACE}/${method}`,
+  service: SERVICE, namespace: NAMESPACE, method, invocation: { kind: 'direct' },
+  parameters: [{ name: 'request', wire: 'request', source: 'json', codec: { mode: 'src-json' } }], result: { mode: 'src-json' } }));
+export function installGoalWeb(ctx) {
+  return ctx.inject(['arcfoldGoals', 'sessionController', 'agents', 'agentPresets', 'connection'], function goalWeb(owner) { new GoalWeb(owner); });
+}

package/src/goal-locales.mjs

@@ -0,0 +1,78 @@
+export const goalZh = {
+  goalCurrentWork: '当前工作', goalNoCurrentWork: '此目标尚未关联具体工作。', goalOtherWork: '其他工作',
+  goalEvidence: '目标依据与历史记录', goalUnavailable: '目标内容暂不可用', goalWorkOriginal: '完整委托与来源',
+  goalBlockReason: '阻塞原因', goalBlockUnknown: '执行已受阻，但尚未记录具体原因。',
+  goalBlockRoundLimit: '已达到这次委托允许的连续执行次数。',
+  goalBlockQueueFailed: '下一轮工作未能加入执行队列。', goalBlockPromptRejected: '下一轮工作在开始前被拒绝。',
+  goalDraftChanged: '目标内容已更新。草稿已保留，请核对当前内容并编辑草稿后再发送。',
+  goalTitle: '长期目标', goalOpen: '查看目标', goalHide: '收起目标', goalEmpty: '目前没有可显示的长期目标。',
+  goalLoading: '正在读取目标…', goalOutcome: '希望实现的结果', goalProgress: '已记录的进展', goalRelations: '与其他目标的关系',
+  goalDefinition: '定义版本', goalTracking: '追踪中', goalPaused: '已暂停追踪', goalClosed: '已结束追踪',
+  goalPart: '组成', goalSupports: '支持', goalDerived: '由此形成', goalRelationReview: '定义已变化，关系待复核',
+  goalRelationUnavailable: '关系依据已失效', goalResume: '恢复追踪', goalPause: '暂停追踪', goalClose: '结束追踪',
+  goalBoundary: 'Arcfold 从交流和共同经历中整理目标，把相关工作、背景和进展联系起来。你可以在对话中补充或纠正；一次工作完成不代表长期目标已经实现。',
+  goalSaved: '追踪决定已保存，不会因此启动工作。', goalDiscuss: '围绕此目标发送', goalRepair: '用新原话重新澄清',
+  goalDiscussLabel: '本次要发送的原话', goalDiscussHelp: '点击后把这段原话发送到当前交流，并只为这一次消息关联所选目标；不会恢复暂停或结束的追踪。',
+  goalRepairHelp: '旧依据已经失效。这里只发送你这次的新原话供重新澄清，不引用失效旧内容，也不恢复追踪。',
+  goalAccepted: '宿主已受理这次发送；目标关联须等这条真实消息进入当前工作后才生效。',
+  goalUnknown: '这次发送是否受理尚未确认。再次点击只查询同一请求，不会自动重发。请先核对当前交流。',
+  goalFailed: '发送前已停止；没有重新发送。请核对当前交流后另行决定。',
+  goalConflict: '目标已变化，请读完更新后的目标，再明确决定是否发送或改变追踪状态。',
+  goalLinkedWork: '已关联的工作', goalContribution: '助手当时的关联判断（依据当时定义版本）', goalUnassessed: '贡献效果尚未评估',
+  goalContributionUnavailable: '关联判断的依据已失效或无法核对，暂不展示旧正文。',
+  goalProgressUnavailable: '进展依据已失效，暂不作为当前依据。',
+  goalNoProgress: '尚未记录进展。', goalNoRelations: '尚未记录目标关系。', goalNoLinks: '尚未关联工作。',
+  goalHistory: '本交流最近的目标讨论发送记录', goalOriginal: '发送原话', goalAdmission: '受理状态',
+  goalMainRequired: '请打开当前的 Arcfold 主交流，再从这里发送目标讨论。',
+  goalWorkTitle: '相关工作与实际进展', goalWorkHelp: '要修改或继续工作，直接在对话中告诉 Arcfold。停止推进只暂停这件工作的自动继续。',
+  goalWorkEnabled: '持续推进已开启', goalWorkDisarmed: '待继续', goalWorkPaused: '已暂停',
+  goalWorkBlocked: '推进受阻', goalWorkComplete: '这件工作已完成', goalWorkRounds: '已开始的工作轮次',
+  goalWorkVerified: '已核对原始委托', goalWorkLegacy: '历史委托尚未核对', goalWorkFor: '对应目标：',
+  goalWorkUnlinked: '目标联系待整理', goalWorkRelationReview: '这项联系需要重新核对。',
+  goalWorkReadGoal: '查看对应目标', goalWorkStop: '停止这件工作的推进', goalWorkStopped: '这件工作的后续推进已暂停。',
+  goalWorkUnknown: '操作结果尚未确认，请先刷新查看实际状态。再次点击会核对同一请求。',
+  goalWorkResume: '继续这件工作', goalWorkResumed: '这件工作已启用后续推进。', goalWorkDetails: '查看工作详情',
+  goalWorkLinked: '已关联目标', goalCorrection: '补充或纠正',
+  goalWorkCleared: '不再作为当前工作', goalWorkSourceUnavailable: '委托来源已失效',
+  goalStageWaiting: '等待明确下一步', goalStageComplete: '当前阶段已完成', goalStageReview: '待明确当前阶段',
+  goalStageDoneWhen: '完成条件：', goalStageBoundaries: '推进范围：',
+};
+export const goalEn = {
+  goalCurrentWork: 'Current work', goalNoCurrentWork: 'No work is linked to this goal yet.', goalOtherWork: 'Other work',
+  goalEvidence: 'Goal sources and history', goalUnavailable: 'Goal content unavailable', goalWorkOriginal: 'Full delegation and sources',
+  goalBlockReason: 'Blocking reason', goalBlockUnknown: 'Execution is blocked; no specific reason is recorded.',
+  goalBlockRoundLimit: 'This delegation reached its allowed number of continuation rounds.',
+  goalBlockQueueFailed: 'The next round could not be queued.', goalBlockPromptRejected: 'The next round was rejected before starting.',
+  goalDraftChanged: 'The goal changed. Your draft is preserved; review the current content and edit your draft before sending.',
+  goalTitle: 'Long-term goals', goalOpen: 'Read goal', goalHide: 'Hide goals', goalEmpty: 'No long-term goals are available.',
+  goalLoading: 'Loading goals…', goalOutcome: 'Intended outcome', goalProgress: 'Recorded progress', goalRelations: 'Related goals',
+  goalDefinition: 'Definition version', goalTracking: 'Tracking', goalPaused: 'Tracking paused', goalClosed: 'Tracking ended',
+  goalPart: 'Part of', goalSupports: 'Supports', goalDerived: 'Derived from', goalRelationReview: 'Definition changed; relation needs review',
+  goalRelationUnavailable: 'Relation evidence unavailable', goalResume: 'Resume tracking', goalPause: 'Pause tracking', goalClose: 'End tracking',
+  goalBoundary: 'Arcfold connects goals, related work, context and progress from conversations and shared experience. Clarify or correct them in conversation. Completing a piece of work does not establish that a long-term goal has been achieved.',
+  goalSaved: 'Tracking decision saved. No work is started by this decision.', goalDiscuss: 'Send about this goal', goalRepair: 'Clarify with new words',
+  goalDiscussLabel: 'Your words to send', goalDiscussHelp: 'Send these exact words to this conversation and relate only that submission to this goal. Paused or ended tracking remains unchanged.',
+  goalRepairHelp: 'Prior evidence is unavailable. Only your new words will be sent for clarification; invalid old content is not used and tracking is not resumed.',
+  goalAccepted: 'The host accepted the submission. The relation takes effect only when that real message enters the current work.',
+  goalUnknown: 'Admission is unconfirmed. Clicking again only reads the same request and never resends it. Check the conversation first.',
+  goalFailed: 'Stopped before submission; not resent. Check the conversation before deciding what to do next.',
+  goalConflict: 'The goal changed. Read the updated goal before deciding again.',
+  goalLinkedWork: 'Related work', goalContribution: 'Assistant interpretation at the recorded definition version', goalUnassessed: 'Contribution effect not assessed',
+  goalContributionUnavailable: 'The interpretation evidence is unavailable or cannot be verified; prior wording is not shown.',
+  goalProgressUnavailable: 'Progress evidence is unavailable and is not used as current evidence.',
+  goalNoProgress: 'No progress is recorded.', goalNoRelations: 'No relations are recorded.', goalNoLinks: 'No work is linked.',
+  goalHistory: 'Recent goal discussion submissions in this conversation', goalOriginal: 'Submitted words', goalAdmission: 'Admission',
+  goalMainRequired: 'Open the current Arcfold main conversation to send a goal discussion here.',
+  goalWorkTitle: 'Related work and actual progress', goalWorkHelp: 'Tell Arcfold in conversation when you want to change or continue work. Stopping pauses only this work’s automatic continuation.',
+  goalWorkEnabled: 'Automatic continuation enabled', goalWorkDisarmed: 'Awaiting continuation', goalWorkPaused: 'Paused',
+  goalWorkBlocked: 'Work blocked', goalWorkComplete: 'This work is complete', goalWorkRounds: 'Rounds started',
+  goalWorkVerified: 'Original delegation verified', goalWorkLegacy: 'Historical delegation not yet verified', goalWorkFor: 'Related goal:',
+  goalWorkUnlinked: 'Goal relation not yet recorded', goalWorkRelationReview: 'This relation needs to be checked again.',
+  goalWorkReadGoal: 'Read related goal', goalWorkStop: 'Stop this work’s continuation', goalWorkStopped: 'This work’s continuation is paused.',
+  goalWorkUnknown: 'The action result is unconfirmed. Refresh to inspect actual execution. Clicking again checks the same request.',
+  goalWorkResume: 'Continue this work', goalWorkResumed: 'Continuation is enabled for this work.', goalWorkDetails: 'Read work details',
+  goalWorkLinked: 'A related goal', goalCorrection: 'Clarify or correct',
+  goalWorkCleared: 'No longer the current work', goalWorkSourceUnavailable: 'Delegation source is unavailable',
+  goalStageWaiting: 'Awaiting the next decision', goalStageComplete: 'Current stage completed', goalStageReview: 'Current stage needs clarification',
+  goalStageDoneWhen: 'Completion criteria:', goalStageBoundaries: 'Scope:',
+};

package/src/goal-source.mjs

@@ -0,0 +1,72 @@
+import { requireViewScope, viewScopeFields } from './browse-source.mjs';
+export async function callGoal(rpc, endpoint, payload, signal) {
+  const result = await rpc.call('/api', `arcfoldGoals/${endpoint}`, { args: { request: payload } }, signal);
+  if (result?.ok !== true) throw Object.assign(new Error(result?.error?.message || '目标请求未完成。'),
+    { code: result?.error?.code || 'goal_request_failed', remote: true });
+  return result.value;
+}
+
+// Read-only UI cache. Mutations occur only in explicit click handlers.
+export function createGoalSource({ rpc, sessionId, viewScope, subscribeReset, intervalMs = 5000 }) {
+  viewScopeFields(viewScope);
+  let snapshot = { loading: true, error: null, items: [], works: [], total: 0, offset: 0, nextOffset: null, readEpoch: 0 };
+  let generation = 0, controller, timer, reset, disposed = false;
+  const listeners = new Set(), reads = new Set();
+  const publish = value => { snapshot = { ...snapshot, ...value }; for (const listener of listeners) listener(); };
+  const cancelled = () => Object.assign(new Error('查看范围已变化，请重新打开目标。'), { code: 'goal_read_cancelled' });
+  function invalidateReads({ clear = true } = {}) {
+    controller?.abort(); generation++;
+    for (const read of reads) read.abort();
+    publish({ loading: true, error: null, readEpoch: snapshot.readEpoch + 1,
+      ...(clear ? { items: [], works: [], total: 0, offset: 0, nextOffset: null, canDiscuss: false } : {}) });
+  }
+  async function refresh(offset = snapshot.offset) {
+    if (disposed) return;
+    controller?.abort(); controller = new AbortController();
+    const current = ++generation, signal = controller.signal;
+    try {
+      const result = await callGoal(rpc, 'list', { sessionId, offset, limit: 20, ...viewScopeFields(viewScope) }, signal);
+      if (current !== generation || signal.aborted || disposed) return;
+      publish({ ...result, offset, loading: false, error: null });
+    } catch (error) {
+      if (current === generation && !signal.aborted && !disposed)
+        publish({ loading: false, error: error instanceof Error ? error.message : '读取目标失败。' });
+    }
+  }
+  function stop() { clearInterval(timer); timer = undefined; reset?.(); reset = undefined; invalidateReads(); }
+  return {
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      if (disposed) return () => {};
+      listeners.add(listener);
+      if (listeners.size === 1) {
+        void refresh(); timer = setInterval(() => { void refresh(); }, intervalMs);
+        // A reconnect invalidates pending reads, but does not erase the user's
+        // unsent goal discussion. A changed goal revision still makes it stale.
+        reset = subscribeReset(() => { invalidateReads({ clear: false }); void refresh(); });
+      }
+      return () => { listeners.delete(listener); if (!listeners.size) stop(); };
+    },
+    refresh,
+    setViewScope(value) {
+      requireViewScope(value);
+      if (disposed || viewScope === value) return;
+      viewScope = value; invalidateReads();
+      if (listeners.size) void refresh(0);
+    },
+    async details(goalId) {
+      if (disposed) throw cancelled();
+      const read = new AbortController(), epoch = snapshot.readEpoch; reads.add(read);
+      try {
+        const value = await callGoal(rpc, 'details', { goalId, sessionId, ...viewScopeFields(viewScope) }, read.signal);
+        if (disposed || read.signal.aborted || epoch !== snapshot.readEpoch) throw cancelled();
+        return value;
+      } finally { reads.delete(read); }
+    },
+    async decide(request) { const result = await callGoal(rpc, 'decide', request); await refresh(); return result; },
+    async stopWork(request) { const result = await callGoal(rpc, 'stopWork', { ...request, sessionId }); await refresh(); return result; },
+    async resumeWork(request) { const result = await callGoal(rpc, 'resumeWork', { ...request, sessionId }); await refresh(); return result; },
+    discuss: request => callGoal(rpc, 'discuss', { ...request, sessionId }),
+    dispose() { disposed = true; stop(); listeners.clear(); },
+  };
+}

package/src/import-host.mjs

@@ -0,0 +1,98 @@
+import { currentMainAgent } from './main-session.mjs';
+import { browseScope } from './browse-scope.mjs';
+import { TypertRemoteService, RemoteError } from '@deepseek-ai/dsh-typert-protocol';
+const NAMESPACE='arcfoldImports',SERVICE='arcfoldImportWeb';
+const ENDPOINTS=['prepare','list','details','confirm','withdraw'];
+export const MAX_IMPORT_FILE_BYTES=805306368;
+const reject=(code,message)=>{throw new RemoteError(code,message,{});};
+function shape(value,allowed,required=allowed){
+  if(!value||typeof value!=='object'||Array.isArray(value)||Object.keys(value).some(k=>!allowed.includes(k))||required.some(k=>!Object.hasOwn(value,k)))
+    reject('invalid_import_request','导入请求含缺失或未允许的字段。');
+}
+function id(value){if(typeof value!=='string'||!value.trim()||value.length>512||value.includes('\0'))reject('invalid_import_request','请求身份无效。');}
+function trusted(connection,signal,peer){
+  if(!peer||peer!==connection.browserPeer||peer.principal?.kind!=='owner'||peer.interactions!=='answer'||peer.signal?.aborted!==false||signal?.aborted!==false)
+    reject('trusted_browser_required','导入只接受当前已认证网页所有者的请求。');
+}
+const errors={revision_conflict:'预览版本已变化，请重新查看。',import_identity_conflict:'提交编号已绑定另一份内容，未重发。',
+  invalid_browse_scope:'请选择全部积累或与当前聊天相关的内容。',
+  invalid_import_page:'分页范围无效。',import_not_found:'导入批次不存在。',import_text_denied:'原文不属于此批预览。',
+  import_not_confirmable:'请在准备预览的同一个主交流确认完整预览。',import_not_withdrawable:'此批次尚不可撤销。',
+  import_already_withdrawn:'相同来源批次已撤销，重复准备不会重新启用。',import_dependency_changed:'已保存预览的证据已变化，未导入。',
+  invalid_import_scope:'只能选择一个旧交流映射到当前主交流。',invalid_import_request:'导入请求无效。',invalid_import_file:'附件大小或摘要无效。'};
+
+export function createImportHandler({imports,connection,agents,agentPresets,fileUploads,attachments}){
+  const main=sessionId=>{
+    const agent=currentMainAgent({agents,agentPresets},sessionId);
+    if(!agent)
+      reject('import_session_denied','请在当前已打开的 Arcfold 主交流导入。');
+    return agent;
+  };
+  return async(endpoint,payload,signal,peer)=>{
+    try{
+      trusted(connection,signal,peer);
+      if(!imports)reject('import_unavailable','当前部署尚未接通导入。');
+      const fields=endpoint==='prepare'?['sessionId','receiptId','requestId','scopeMap']:
+        endpoint==='list'?['sessionId','offset','limit','viewScope']:endpoint==='details'?['sessionId','batchId','view','offset','limit','textKey','viewScope']:
+        ['sessionId','batchId','expectedRevision','previewHash','requestId'];
+      const required=endpoint==='prepare'?['sessionId','receiptId','requestId']:endpoint==='list'?['sessionId']:
+        endpoint==='details'?['sessionId','batchId']:fields;
+      if(!ENDPOINTS.includes(endpoint))reject('import_endpoint_not_found','不存在的导入操作。');
+      shape(payload,fields,required);id(payload.sessionId);
+      const reading=endpoint==='list'||endpoint==='details';
+      if(reading)browseScope(payload.viewScope,'all');
+      if(reading&&payload.viewScope!==undefined)return {...imports[endpoint](payload),
+        canImport:currentMainAgent({agents,agentPresets},payload.sessionId)!==null};
+      const agent=main(payload.sessionId);
+      if(endpoint==='list'||endpoint==='details')return imports[endpoint](payload);
+      id(payload.requestId);
+      if(endpoint!=='prepare')return imports[endpoint]({...payload,userIdentity:'browser:'+peer.id});
+      id(payload.receiptId);
+      if(payload.scopeMap!==undefined){
+        if(!Array.isArray(payload.scopeMap)||payload.scopeMap.length>1)reject('invalid_import_scope',errors.invalid_import_scope);
+        for(const row of payload.scopeMap){shape(row,['sourceConversationId','targetSessionId']);id(row.sourceConversationId);
+          if(row.targetSessionId!==payload.sessionId)reject('invalid_import_scope',errors.invalid_import_scope);}
+      }
+      const prior=imports.replayPreparation(payload);if(prior)return await prior;
+      const staged=fileUploads?.resolve(agent,payload.receiptId),ref=staged?.attachment;
+      if(staged?.type!=='file'||!ref||typeof ref.attachmentId!=='string'||!/^sha256:[a-f0-9]{64}$/.test(ref.attachmentId)||
+          typeof ref.name!=='string'||ref.name.length>512||!Number.isSafeInteger(ref.bytes)||ref.bytes<0||ref.bytes>MAX_IMPORT_FILE_BYTES)
+        reject('import_receipt_denied','附件凭证不属于当前真实主交流，或超出导入上限。');
+      const frozen={attachmentId:ref.attachmentId,name:ref.name,bytes:ref.bytes};
+      const current=()=>{
+        trusted(connection,signal,peer);
+        if(main(payload.sessionId)!==agent||fileUploads.resolve(agent,payload.receiptId)!==staged||
+            ref.attachmentId!==frozen.attachmentId||ref.name!==frozen.name||ref.bytes!==frozen.bytes)
+          reject('import_receipt_changed','上传凭证或主交流已变化。');
+      };
+      current();
+      return await imports.prepare({...payload,file:{name:frozen.name,bytes:frozen.bytes,sha256:frozen.attachmentId.slice(7)},
+        userIdentity:'browser:'+peer.id,signal:AbortSignal.any([signal,peer.signal]),
+        read:async function*(abort){
+          current();for await(const chunk of attachments.readFileStream(frozen,abort)){current();abort.throwIfAborted();yield chunk;}
+          // Native digest check happens after its last yield; do not mark ready earlier.
+          current();abort.throwIfAborted();
+        }});
+    }catch(error){
+      if(error instanceof RemoteError)throw error;
+      const code=Object.hasOwn(errors,error?.code)?error.code:'import_request_failed';
+      throw new RemoteError(code,errors[code]||'操作未确认，请刷新批次记录。没有自动重试。',{});
+    }
+  };
+}
+class ImportWeb extends TypertRemoteService{
+  constructor(ctx){super(ctx,SERVICE,{namespace:NAMESPACE});}
+  dispatch(method,request){const {signal,peer}=this.ctx.invocation??{};
+    return createImportHandler({imports:this.ctx.arcfoldImports,connection:this.ctx.connection,agents:this.ctx.agents,
+      agentPresets:this.ctx.agentPresets,fileUploads:this.ctx.fileUploads,attachments:this.ctx.attachments})(method,request,signal,peer);}
+  prepare(value){return this.dispatch('prepare',value);}
+  list(value){return this.dispatch('list',value);}
+  details(value){return this.dispatch('details',value);}
+  confirm(value){return this.dispatch('confirm',value);}
+  withdraw(value){return this.dispatch('withdraw',value);}
+}
+export const importInvocations=ENDPOINTS.map(method=>({id:`@arcfold/dsh-method-ui#${NAMESPACE}/${method}`,
+  service:SERVICE,namespace:NAMESPACE,method,invocation:{kind:'direct'},
+  parameters:[{name:'request',wire:'request',source:'json',codec:{mode:'src-json'}}],result:{mode:'src-json'}}));
+export function installImportWeb(ctx){return ctx.inject(['arcfoldImports','connection','agents','agentPresets','fileUploads','attachments'],
+  owner=>{new ImportWeb(owner);});}