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

package/src/import-locales.mjs

@@ -0,0 +1,126 @@
+export const importsZh = {
+  importSnapshot:'以下为当时保存的导入预览，资格、来源状态和试用次数不代表当前状态。',
+  importWithdrawnNotice:'这批导入已撤回，不再作为当前依据。以下保留当时预览和原文。',
+  importCountsAtPreview:'当时预览统计', importEligibilityAtPreview:'当时预览资格',
+  importSourceAtPreview:'当时来源状态', importUsageAtPreview:'导入时试用次数',
+  importContent:'读取完整内容', importOriginalRecord:'查看保留的旧记录',
+  importAppliesTo:'适用情况', importDoesNotApplyTo:'不适用情况', importTopics:'原主题范围',
+  importAttributeUnavailable:'这项内容不完整或超出可采用范围，请查看保留的旧记录。',
+  importClaimInference:'AI 推断', importClaimLiteral:'用户明确陈述', importClaimQuestion:'待确认的问题',
+  importReason_user_authored_range_unproven:'无法确认这段引文是用户自己的陈述，而非他引用的资料。',
+  "importReason_old_state_not_current":"旧记录已停止使用，或无法确认它仍然有效。",
+  "importReason_source_closure_unproven":"无法完整核对这条记录所依据的来源。",
+  "importReason_source_reference_unproven":"引用的来源或版本无法核对。",
+  "importReason_source_range_mismatch":"引文与原文中的位置不一致。",
+  "importReason_old_tasks_history_only":"旧事项保留为历史，不会恢复执行。",
+  "importReason_source_cycle":"依据之间存在循环引用，需要核对。",
+  "importReason_old_record_not_current":"旧记录的状态、版本或保存时间范围无法确认。",
+  "importReason_source_unavailable":"所依赖的来源已撤回、缺失或不可用。",
+  "importReason_source_revision_unproven":"缺少原来源版本依据，不能按最新版本补齐。",
+  "importReason_dependency_version_unproven":"依赖的理解或方法已经变化，或其版本无法核对。",
+  "importReason_method_contract_unproven":"方法内容、适用条件或状态不完整。",
+  "importReason_method_trial_basis_unknown":"缺少原试用次数依据，不会重新按零次开始。",
+  "importReason_method_trial_history_mismatch":"原试用次数与采用记录不一致。",
+  "importReason_method_active_authority_unproven":"无法确认此前继续采用这条方法的明确决定。",
+  "importReason_historical_control_not_migrated":"保留目标或机会的历史，暂不迁入控制或执行状态。",
+  "importReason_scope_not_mapped":"这条记录只适用于旧交流，尚未关联当前会话。",
+  "importReason_dependency_not_eligible":"所依赖的其他记录在本批预览中不可采用。",
+  "importReason_method_already_present":"方法已存在，沿用当前状态和已用次数，不会重新试用。",
+  "importReason_method_existing_conflict":"与已有方法的内容或范围不一致，不会覆盖现有决定。",
+  "importReason_method_batch_conflict":"这批旧记录中有重复方法，需先核对；不会重复增加试用次数。",
+  "importReason_dependency_scope_mismatch":"依赖材料的适用范围更窄，不能扩大到其他交流。",
+  "importReason_scope_unsupported":"旧适用范围无法准确迁入，需要核对后再使用。",
+  "importRole_user":"用户原话",
+  "importRole_assistant":"助手回答",
+  "importRole_tool":"工具结果",
+  "importRole_system":"系统信息",
+  "importRole_material":"资料",
+  "importRole_program":"程序产生的信息",
+  "importRoleUnknown":"来源角色待核对",
+  "importReasonUnrecognized":"这条记录还需要进一步核对。",
+  "importExistingRecord":"对应已有方法记录",
+
+  importWorking:'正在处理…', importTitle:'旧历史导入', importOpen:'查看导入', importHide:'收起导入', importEmpty:'还没有导入批次。',
+  importBoundary:'先选择完整导出文件并查看预览。只有确认后，列出的理解与方法才会按其适用范围进入后续交流；不会恢复旧任务或授予执行权限。',
+  importFile:'完整导出文件（最多 768 MiB）', importPrepare:'上传并预览', importPreparing:'正在上传或核对完整文件…',
+  importStorage:'上传的文件会保存在本地附件中。未确认的预览不会影响回答；撤回后保留原文与操作记录。',
+  importLoading:'正在读取导入记录…', importPreview:'查看这一批', importRecords:'理解、方法与历史', importSources:'原始来源',
+  importText:'读取完整原文', importTextPage:'完整内容（分段）', importExcerpt:'以下是节选，可分段查看完整原文。',
+  importReady:'待确认', importPreparingStatus:'准备中', importFailed:'准备失败', importConfirmed:'已导入', importWithdrawn:'已撤回',
+  importScopeTitle:'旧交流的适用范围', importKeepScope:'保留原范围；旧会话内容仅作为历史',
+  importMapScope:'将选中的一段旧交流关联到当前会话', importScopeHelp:'全局内容仍按原全局范围处理。最多关联一段旧交流；其他旧会话保留为历史，不影响当前交流。',
+  importScopeChanged:'范围已修改。请先重新生成预览，再确认导入。', importReprepare:'按新范围生成预览',
+  importNoReceipt:'若要修改范围，请重新选择原导出文件并预览。', importMapped:'关联到当前会话', importHistoricalScope:'保留在旧会话', importGlobal:'沿用原全局范围',
+  importConfirm:'确认导入这一批', importConfirmHelp:'这一次确认包含本批列出的指导内容和方法试用次数。原文与推断仍有区别，导入不表示内容已经证实。',
+  importWithdraw:'撤回这一批的采用', importWithdrawHelp:'撤回后将停止采用依赖本批来源的理解、方法与目标依据；独立的新经历仍保留，目标的暂停或关闭状态不变，已执行的工作不会撤销。',
+  importOtherSession:'这是另一段会话准备的预览，请回到原会话确认。',
+  importUnknown:'结果尚未确认，没有自动重发。请刷新批次查看实际状态。', importSaved:'导入状态已更新。',
+  importEnabled:'可采用', importTrial:'有限试用', importPaused:'保持暂停', importHistory:'仅保留历史', importNeedsReview:'需要核对',
+  importCountSources:'来源', importCountRecords:'记录', importRemaining:'剩余试用次数', importUsed:'已用', importMaximum:'上限',
+  importUnavailable:'来源不可用', importAvailable:'来源可用', importRevision:'预览版本', importFileHash:'文件指纹',
+  importReadMore:'下一段', importReadPrevious:'上一段', importReason:'资格核对结果', importFileTooLarge:'请选择不超过 768 MiB 的非空导出文件。',
+};
+export const importsEn = {
+  importSnapshot:'This is the saved import preview. Eligibility, source availability and trial counts describe that preview, not the current state.',
+  importWithdrawnNotice:'This batch has been withdrawn and is no longer used as evidence. Its original preview and source text remain below.',
+  importCountsAtPreview:'Preview counts', importEligibilityAtPreview:'Eligibility at preview',
+  importSourceAtPreview:'Source state at preview', importUsageAtPreview:'Trial counts at import',
+  importContent:'Read full content', importOriginalRecord:'View retained earlier record',
+  importAppliesTo:'Applies to', importDoesNotApplyTo:'Does not apply to', importTopics:'Original topics',
+  importAttributeUnavailable:'This field is incomplete or outside the eligible bounds. View the retained earlier record.',
+  importClaimInference:'AI inference', importClaimLiteral:'Explicit user statement', importClaimQuestion:'Open question',
+  importReason_user_authored_range_unproven:'The quotation is not proven to be the user’s own statement rather than cited material.',
+  "importReason_old_state_not_current":"The earlier state is stopped or unproven.",
+  "importReason_source_closure_unproven":"The complete supporting evidence is unproven.",
+  "importReason_source_reference_unproven":"The cited source or version is unproven.",
+  "importReason_source_range_mismatch":"The quotation does not match its recorded position.",
+  "importReason_old_tasks_history_only":"Earlier tasks remain historical and do not resume execution.",
+  "importReason_source_cycle":"The evidence contains a circular reference.",
+  "importReason_old_record_not_current":"The earlier state, version or snapshot boundary is unproven.",
+  "importReason_source_unavailable":"A supporting source is withdrawn, missing or unavailable.",
+  "importReason_source_revision_unproven":"The original source version is unproven and cannot be replaced with the latest version.",
+  "importReason_dependency_version_unproven":"A supporting record changed or its version is unproven.",
+  "importReason_method_contract_unproven":"The method content, applicability or state is incomplete.",
+  "importReason_method_trial_basis_unknown":"Trial history is missing; usage will not restart from zero.",
+  "importReason_method_trial_history_mismatch":"Trial counts and adoption records disagree.",
+  "importReason_method_active_authority_unproven":"The earlier explicit continuation decision is unproven.",
+  "importReason_historical_control_not_migrated":"Goal or opportunity history is retained without restoring controls or execution.",
+  "importReason_scope_not_mapped":"The earlier conversation is not connected here.",
+  "importReason_dependency_not_eligible":"A supporting record is not eligible in this preview.",
+  "importReason_method_already_present":"The method already exists; its current state and usage are retained.",
+  "importReason_method_existing_conflict":"It conflicts with an existing method or scope and will not overwrite the current decision.",
+  "importReason_method_batch_conflict":"These old records contain duplicate methods; review them first. Trial uses will not be duplicated.",
+  "importReason_dependency_scope_mismatch":"A supporting record has a narrower scope and cannot be used in other conversations.",
+  "importReason_scope_unsupported":"The earlier scope cannot be transferred accurately and needs review.",
+  "importRole_user":"User",
+  "importRole_assistant":"Assistant",
+  "importRole_tool":"Tool result",
+  "importRole_system":"System",
+  "importRole_material":"Material",
+  "importRole_program":"Program-generated information",
+  "importRoleUnknown":"Source role unconfirmed",
+  "importReasonUnrecognized":"This record needs further review.",
+  "importExistingRecord":"View existing record reference",
+
+  importWorking:'Processing…', importTitle:'Import history', importOpen:'View imports', importHide:'Hide imports', importEmpty:'No import batches yet.',
+  importBoundary:'Choose a complete export and review its preview. Understanding and methods become eligible only after confirmation, within the displayed scope. Old tasks and execution permissions are not restored.',
+  importFile:'Complete export (up to 768 MiB)', importPrepare:'Upload and preview', importPreparing:'Uploading or checking the complete file…',
+  importStorage:'Uploaded files remain in local attachments. Unconfirmed previews do not affect answers. Withdrawal retains originals and audit records.',
+  importLoading:'Loading import records…', importPreview:'View this batch', importRecords:'Understanding, methods and history', importSources:'Original sources',
+  importText:'Read full original', importTextPage:'Complete content segments', importExcerpt:'This is an excerpt. The complete original is available in segments.',
+  importReady:'Awaiting confirmation', importPreparingStatus:'Preparing', importFailed:'Preparation failed', importConfirmed:'Imported', importWithdrawn:'Withdrawn',
+  importScopeTitle:'Scope of earlier conversations', importKeepScope:'Keep original scope; earlier conversations remain historical',
+  importMapScope:'Connect the selected earlier conversation to this conversation', importScopeHelp:'Global material retains its global scope. At most one earlier conversation can be connected; all others remain historical.',
+  importScopeChanged:'Scope changed. Generate a new preview before confirming.', importReprepare:'Preview the new scope',
+  importNoReceipt:'To change scope, select the original export file again.', importMapped:'Connected to this conversation', importHistoricalScope:'Earlier conversation only', importGlobal:'Original global scope',
+  importConfirm:'Confirm this batch', importConfirmHelp:'One confirmation covers the listed guidance and method trial counts. Originals and inferences remain distinct; import does not prove their correctness.',
+  importWithdraw:'Withdraw this batch', importWithdrawHelp:'Dependent understanding, methods and goal evidence stop being eligible. Independent new experience remains. Goal pause/close decisions and already executed work are not undone.',
+  importOtherSession:'This preview belongs to another conversation. Confirm it in the original conversation.',
+  importUnknown:'The outcome is unconfirmed. Nothing was resent automatically. Refresh to inspect the batch.', importSaved:'Import status updated.',
+  importEnabled:'Eligible', importTrial:'Limited trial', importPaused:'Remains paused', importHistory:'Historical only', importNeedsReview:'Needs review',
+  importCountSources:'Sources', importCountRecords:'Records', importRemaining:'Trials remaining', importUsed:'Used', importMaximum:'Limit',
+  importUnavailable:'Source unavailable', importAvailable:'Source available', importRevision:'Preview revision', importFileHash:'File fingerprint',
+  importReadMore:'Next segment', importReadPrevious:'Previous segment', importReason:'Eligibility checks', importFileTooLarge:'Choose a nonempty export file up to 768 MiB.',
+};
+
+export const importReasonKeys = Object.freeze(["user_authored_range_unproven", "old_state_not_current", "source_closure_unproven", "source_reference_unproven", "source_range_mismatch", "old_tasks_history_only", "source_cycle", "old_record_not_current", "source_unavailable", "source_revision_unproven", "dependency_version_unproven", "method_contract_unproven", "method_trial_basis_unknown", "method_trial_history_mismatch", "method_active_authority_unproven", "historical_control_not_migrated", "scope_not_mapped", "dependency_not_eligible", "method_already_present", "method_existing_conflict", "method_batch_conflict", "dependency_scope_mismatch", "scope_unsupported"]);

package/src/import-source.mjs

@@ -0,0 +1,83 @@
+import { requireViewScope, viewScopeFields } from './browse-source.mjs';
+// Matches the host acceptance limit; native ordinary uploads have their own policy.
+export const IMPORT_MAX_FILE_BYTES = 805306368;
+export function createImportSource({ rpc, fileUpload, sessionId, viewScope, subscribeReset, intervalMs = 5000 }) {
+  viewScopeFields(viewScope);
+  let snapshot = { loading: true, error: null, items: [], total: 0, offset: 0, nextOffset: null,
+    canImport: viewScope === undefined ? undefined : false, readEpoch: 0 };
+  let generation = 0, listRead, timer, reset, disposed = false;
+  const listeners = new Set(), pending = new Set();
+  const stopped = () => Object.assign(new Error('连接已经变化，请重新读取导入记录。'), { code: 'import_request_cancelled' });
+  const publish = value => { snapshot = { ...snapshot, ...value }; for (const listener of listeners) listener(); };
+  async function operation(fn) {
+    if (disposed) throw stopped();
+    const controller = new AbortController(), epoch = snapshot.readEpoch; pending.add(controller);
+    try {
+      const result = await fn(controller.signal);
+      if (disposed || controller.signal.aborted || epoch !== snapshot.readEpoch) throw stopped();
+      return result;
+    } finally { pending.delete(controller); }
+  }
+  async function call(endpoint, request, signal) {
+    const scope = ['list', 'details'].includes(endpoint) ? viewScopeFields(viewScope) : {};
+    const result = await rpc.call('/api', `arcfoldImports/${endpoint}`, { args: { request: { ...request, sessionId, ...scope } } }, signal);
+    if (result?.ok !== true) throw Object.assign(new Error(result?.error?.message || '导入操作未完成。'),
+      { code: result?.error?.code || 'import_request_failed', remote: true });
+    return result.value;
+  }
+  function invalidate() {
+    listRead?.abort(); generation++;
+    for (const controller of pending) controller.abort();
+    publish({ loading: true, error: null, items: [], total: 0, offset: 0, nextOffset: null,
+      canImport: viewScope === undefined ? undefined : false, readEpoch: snapshot.readEpoch + 1 });
+  }
+  async function refresh(offset = snapshot.offset) {
+    if (disposed) return;
+    listRead?.abort(); listRead = new AbortController();
+    const current = ++generation, signal = listRead.signal;
+    try {
+      const result = await call('list', { offset, limit: 20 }, signal);
+      if (!disposed && !signal.aborted && current === generation) publish({ ...result, offset, loading: false, error: null });
+    } catch (error) {
+      if (!disposed && !signal.aborted && current === generation) publish({ loading: false, error: error.message });
+    }
+  }
+  function stop() { clearInterval(timer); timer = undefined; reset?.(); reset = undefined; invalidate(); }
+  return {
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      if (disposed) return () => {};
+      listeners.add(listener);
+      if (listeners.size === 1) {
+        void refresh(); timer = setInterval(() => { void refresh(); }, intervalMs);
+        reset = subscribeReset(() => { invalidate(); void refresh(0); });
+      }
+      return () => { listeners.delete(listener); if (!listeners.size) stop(); };
+    },
+    refresh,
+    setViewScope(value) {
+      requireViewScope(value);
+      if (disposed || viewScope === value) return;
+      viewScope = value; invalidate();
+      if (listeners.size) void refresh(0);
+    },
+    details: request => operation(signal => call('details', request, signal)),
+    prepare: request => operation(signal => call('prepare', request, signal)),
+    confirm: request => operation(signal => call('confirm', request, signal)),
+    withdraw: request => operation(signal => call('withdraw', request, signal)),
+    upload(file, onProgress) {
+      return operation(async signal => {
+        if (!(file instanceof Blob) || !Number.isSafeInteger(file.size) || file.size < 1 || file.size > IMPORT_MAX_FILE_BYTES)
+          throw Object.assign(new Error('请选择不超过 768 MiB 的完整导出文件。'), { code: 'invalid_import_file', remote: true });
+        // File/Blob preserves the native streaming path; do not read it into a byte array.
+        const result = await fileUpload.upload(sessionId, file, file.name || 'arcfold-export.json', signal, onProgress);
+        if (result?.ok !== true) throw Object.assign(new Error(result?.error?.message || '文件上传未完成。'),
+          { code: result?.error?.code || 'import_upload_failed', remote: true });
+        if (typeof result.value?.receiptId !== 'string' || result.value.file?.bytes !== file.size)
+          throw new Error('上传回执与所选文件不一致，请查看记录后重新选择。');
+        return result.value;
+      });
+    },
+    dispose() { disposed = true; stop(); listeners.clear(); },
+  };
+}

package/src/index.mjs

@@ -0,0 +1,127 @@
+import { opportunityInvocations, installOpportunityWeb } from './opportunity-host.mjs';
+import { importInvocations, installImportWeb } from './import-host.mjs';
+import { understandingInvocations, installUnderstandingWeb } from './understanding-host.mjs';
+// The browser transport supplies identity; no model-facing control is registered here.
+import { TypertRemoteService, RemoteError } from '@deepseek-ai/dsh-typert-protocol';
+import { goalInvocations, installGoalWeb } from './goal-host.mjs';
+import { modelInvocations, installModelWeb } from './model-host.mjs';
+import { browseScope } from './browse-scope.mjs';
+import { treeInvocations, installTreeWeb } from './tree-host.mjs';
+import { desktopInvocations, installDesktopWeb } from './desktop-setup-host.mjs';
+export const name = 'arcfold-method-ui';
+export const inject = ['connection', 'typert', 'typertGateway'];
+export const CHANNEL = '/api';
+export const NAMESPACE = 'arcfoldMethods';
+const SERVICE = 'arcfoldMethodWeb';
+const ENDPOINTS = ['list', 'details', 'cards', 'cardDetails', 'notifications', 'acknowledge', 'decide'];
+
+function invalid(message) {
+  throw Object.assign(new Error(message), { code: 'invalid_method_request' });
+}
+function object(value, allowed, required = []) {
+  if (!value || typeof value !== 'object' || Array.isArray(value) ||
+      Object.keys(value).some(key => !allowed.includes(key)) || required.some(key => !Object.hasOwn(value, key)))
+    invalid('方法请求包含缺失或未允许的字段。');
+  return value;
+}
+function identity(value) {
+  if (typeof value !== 'string' || !value.trim() || value.length > 512 || value.includes('\0'))
+    invalid('请求编号不能为空或超长。');
+}
+function page(payload, notifications = false, scoped = false) {
+  object(payload, notifications ? ['offset', 'limit', 'unread'] : scoped ? ['offset', 'limit', 'sessionId', 'viewScope'] : ['offset', 'limit']);
+  if (scoped) {
+    browseScope(payload.viewScope, 'all');
+    if (payload.viewScope !== undefined || payload.sessionId !== undefined) identity(payload.sessionId);
+  }
+  if (payload.offset !== undefined && (!Number.isSafeInteger(payload.offset) || payload.offset < 0) ||
+      payload.limit !== undefined && (!Number.isSafeInteger(payload.limit) || payload.limit < 1 || payload.limit > (notifications ? 200 : 100)) ||
+      payload.unread !== undefined && typeof payload.unread !== 'boolean') invalid('分页参数不合法。');
+  return payload;
+}
+
+export function createMethodHandler({ methods, connection }) {
+  return async (endpoint, payload, signal, peer) => {
+    try {
+      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' });
+      let value;
+      switch (endpoint) {
+        case 'list': value = methods.listDecisions(page(payload)); break;
+        case 'cards': value = methods.listCards(page(payload, false, true)); break;
+        case 'cardDetails': {
+          object(payload, ['methodId', 'offset', 'limit', 'sessionId', 'viewScope'], ['methodId']); identity(payload.methodId);
+          const { methodId, ...pagination } = payload;
+          value = methods.cardDetails(methodId, page(pagination, false, true)); break;
+        }
+        case 'notifications': value = methods.notifications(page(payload, true)); break;
+        case 'details':
+          object(payload, ['methodId'], ['methodId']); identity(payload.methodId);
+          value = methods.details(payload.methodId); break;
+        case 'acknowledge':
+          object(payload, ['notificationId'], ['notificationId']); identity(payload.notificationId);
+          value = methods.acknowledgeNotification(payload.notificationId); break;
+        case 'decide': {
+          const fields = ['methodId', 'expectedRevision', 'contentHash', 'action', 'requestId'];
+          object(payload, fields, fields);
+          identity(payload.methodId); identity(payload.contentHash); identity(payload.requestId);
+          if (!Number.isSafeInteger(payload.expectedRevision) || payload.expectedRevision < 1 ||
+              !['continue', 'pause'].includes(payload.action)) invalid('决定必须绑定已查看的版本和操作。');
+          value = methods.decide({ ...payload, userIdentity: 'browser:' + peer.id });
+          break;
+        }
+        default: throw Object.assign(new Error('不存在的方法操作。'), { code: 'method_endpoint_not_found' });
+      }
+      return { ok: true, value: await value };
+    } catch (error) {
+      return { ok: false, error: { code: typeof error?.code === 'string' ? error.code : 'method_request_failed',
+        message: error instanceof Error ? error.message : '方法操作未完成。', details: {} } };
+    }
+  };
+}
+
+class MethodWeb extends TypertRemoteService {
+  constructor(ctx) { super(ctx, SERVICE, { namespace: NAMESPACE }); }
+  async dispatch(endpoint, request) {
+    const invocation = this.ctx.invocation;
+    const result = await createMethodHandler({ methods: this.ctx.arcfoldMethods, connection: this.ctx.connection })(
+      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); }
+  cards(request) { return this.dispatch('cards', request); }
+  cardDetails(request) { return this.dispatch('cardDetails', request); }
+  notifications(request) { return this.dispatch('notifications', request); }
+  acknowledge(request) { return this.dispatch('acknowledge', request); }
+  decide(request) { return this.dispatch('decide', request); }
+}
+
+class ArcfoldMode extends TypertRemoteService {
+  constructor(ctx) { super(ctx, 'arcfoldModeWeb', { namespace: 'arcfoldMode' }); }
+  current() {
+    const { peer, signal } = this.ctx.invocation ?? {};
+    if (!peer || peer !== this.ctx.connection.browserPeer || peer.principal?.kind !== 'owner' || peer.interactions !== 'answer' || peer.signal?.aborted !== false || signal?.aborted !== false) throw new RemoteError('TRUSTED_BROWSER_REQUIRED', '当前连接尚未认证。', {});
+    return { goalTreeV3: Boolean(this.ctx.get('arcfoldTreeMode')?.enabled) };
+  }
+}
+export function apply(ctx) {
+  new ArcfoldMode(ctx);
+  ctx.inject(['arcfoldMethods'], owner => { new MethodWeb(owner); });
+  installTreeWeb(ctx);
+  installDesktopWeb(ctx);
+  installGoalWeb(ctx);
+  installModelWeb(ctx);
+  installUnderstandingWeb(ctx);
+  installImportWeb(ctx);
+  installOpportunityWeb(ctx);
+  // Use the existing authenticated Gateway; do not claim its single /api interceptor.
+  ctx.typert.register({ package: '@arcfold/dsh-method-ui', face: 'host', schemas: [],
+    model: { services: [], events: [], objects: [] },
+    invocations: [{ id: '@arcfold/dsh-method-ui#arcfoldMode/current', service: 'arcfoldModeWeb', namespace: 'arcfoldMode', method: 'current', invocation: { kind: 'direct' }, parameters: [], result: { mode: 'src-json' } }, ...desktopInvocations, ...treeInvocations, ...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' } })), ...goalInvocations, ...modelInvocations, ...understandingInvocations, ...importInvocations, ...opportunityInvocations] });
+}

package/src/locales.mjs

@@ -0,0 +1,153 @@
+export const zh = {
+  collaborationTitle: 'Arcfold', collaborationClose: '关闭',
+  collaborationViewScope: '查看范围', collaborationAll: '全部积累', collaborationCurrent: '与当前聊天相关',
+  browseOtherSession: '来自其他聊天', browseReturnToOrigin: '请回到原聊天修改这条记录或继续相关工作。',
+  presentationUnknown: "暂未识别",
+  stateTrial: "试用中",
+  stateActive: "采用中",
+  statePaused: "已暂停",
+  stateUnavailable: '记录暂不可用',
+  stateSuperseded: "已有后继版本",
+  stateWithdrawn: "已停止采用",
+  stateReserved: "已领取，待核对",
+  stateSettled: "已核对",
+  roleUser: "用户",
+  roleAssistant: "助手",
+  roleTool: "工具",
+  roleProgram: "程序",
+  outcomePending: "尚待结束",
+  outcomeCompleted: "本轮已完成",
+  outcomeCancelled: "本轮已取消",
+  outcomeFailed: "本轮失败",
+  outcomeInterrupted: "本轮中断",
+  outcomeUnknown: "本轮结果未知",
+  admissionAccepted: "原生入口已受理",
+  admissionFailed: "提交失败",
+  admissionUnknown: "提交结果未知",
+  actionStopUnderstanding: "停止采用理解",
+  actionWithdrawSource: "撤回来源",
+  actionCorrect: "提交逐字纠正",
+
+  title: '协作方法', pending: '待决定', unread: '未读提醒', loading: '正在读取方法…', empty: '此范围内暂无协作方法。',
+  decisionPrompt: '需要你决定：是否继续采用此版本。', reviewDecision: '查看并决定', viewDetails: '查看详情',
+  history: '历史提醒', backToMethods: '返回方法列表', keepPaused: '保持暂停',
+  open: '查看全文与理由', close: '收起详情', refresh: '刷新', previous: '上一页', next: '下一页',
+  guidance: '完整指导', applies: '适用条件', excludes: '不适用条件', sources: '依据原件', reason: '当前状态与理由',
+  version: '内容版本', revision: '记录版本', status: '状态', usage: '已选入试用', remaining: '剩余次数',
+  pendingAdoptions: '尚待核对的采用', conversation: '交流', turn: '轮次',
+  successors: '后继版本', continue: '继续采用此版本', pause: '暂停采用此版本', busy: '正在保存…',
+  saved: '决定已保存。继续采用不代表效果已经验证，也不增加工作或工具权限。',
+  failed: '操作未完成。', unknown: '结果尚未确认；可再次点击同一操作，沿用原请求编号。',
+  conflict: '方法已变化。请重新查看以下全文和理由，再决定是否提交。',
+  notifications: '停止与到期提醒', read: '已读', acknowledge: '标记已读', noNotifications: '目前没有提醒。',
+  noSources: '没有可显示的原件。', sourceIdentity: '原件身份', sourceTime: '原始时间', author: '作者角色',
+  provenance: '来源归属', retry: '重新读取详情', boundary: '查看与已读不会恢复方法；只有下方按钮会保存你的决定。',
+};
+export const en = {
+  collaborationTitle: 'Arcfold', collaborationClose: 'Close',
+  collaborationViewScope: 'View scope', collaborationAll: 'All records', collaborationCurrent: 'Related to this conversation',
+  browseOtherSession: 'From another conversation', browseReturnToOrigin: 'Return to the original conversation to change this record or continue its work.',
+  presentationUnknown: "Not yet recognized",
+  stateTrial: "In trial",
+  stateActive: "In use",
+  statePaused: "Paused",
+  stateUnavailable: 'Record unavailable',
+  stateSuperseded: "Superseded",
+  stateWithdrawn: "Withdrawn",
+  stateReserved: "Reserved; awaiting reconciliation",
+  stateSettled: "Reconciled",
+  roleUser: "User",
+  roleAssistant: "Assistant",
+  roleTool: "Tool",
+  roleProgram: "Program",
+  outcomePending: "Awaiting turn end",
+  outcomeCompleted: "Turn completed",
+  outcomeCancelled: "Turn cancelled",
+  outcomeFailed: "Turn failed",
+  outcomeInterrupted: "Turn interrupted",
+  outcomeUnknown: "Turn outcome unknown",
+  admissionAccepted: "Accepted by native input",
+  admissionFailed: "Submission failed",
+  admissionUnknown: "Submission outcome unknown",
+  actionStopUnderstanding: "Stop using understanding",
+  actionWithdrawSource: "Withdraw source",
+  actionCorrect: "Submit exact correction",
+
+  title: 'Collaboration methods', pending: 'Awaiting decision', unread: 'Unread notices', loading: 'Loading methods…', empty: 'No collaboration methods in this view.',
+  decisionPrompt: 'Your decision: whether to keep using this version.', reviewDecision: 'Review and decide', viewDetails: 'View details',
+  history: 'Notice history', backToMethods: 'Back to methods', keepPaused: 'Keep paused',
+  open: 'Read full method and reason', close: 'Close details', refresh: 'Refresh', previous: 'Previous', next: 'Next',
+  guidance: 'Full guidance', applies: 'Applies when', excludes: 'Does not apply when', sources: 'Original evidence', reason: 'Current state and reason',
+  version: 'Content version', revision: 'Record revision', status: 'State', usage: 'Trial selections', remaining: 'Remaining',
+  pendingAdoptions: 'Selections awaiting reconciliation', conversation: 'Conversation', turn: 'Turn',
+  successors: 'Later versions', continue: 'Continue this version', pause: 'Pause this version', busy: 'Saving…',
+  saved: 'Decision saved. Continuing does not validate effectiveness or grant additional work or tool permissions.',
+  failed: 'The action did not complete.', unknown: 'Outcome not confirmed; repeat the same action to reuse its request ID.',
+  conflict: 'The method changed. Read the refreshed guidance and reason before deciding again.',
+  notifications: 'Pause and trial notices', read: 'Read', acknowledge: 'Mark read', noNotifications: 'No notices.',
+  noSources: 'No original evidence is available to display.', sourceIdentity: 'Source identity', sourceTime: 'Original time', author: 'Author role',
+  provenance: 'Provenance', retry: 'Reload details', boundary: 'Viewing or marking read does not resume a method. Only these controls save your decision.',
+};
+
+const presentationKeys = {
+  "method": {
+    "trial": "stateTrial",
+    "active": "stateActive",
+    "paused": "statePaused",
+    "unavailable": "stateUnavailable",
+    "superseded": "stateSuperseded"
+  },
+  "understanding": {
+    "active": "stateActive",
+    "withdrawn": "stateWithdrawn",
+    "superseded": "stateSuperseded"
+  },
+  "adoption": {
+    "reserved": "stateReserved",
+    "settled": "stateSettled"
+  },
+  "role": {
+    "user": "roleUser",
+    "assistant": "roleAssistant",
+    "tool": "roleTool",
+    "program": "roleProgram"
+  },
+  "outcome": {
+    "pending": "outcomePending",
+    "completed": "outcomeCompleted",
+    "cancelled": "outcomeCancelled",
+    "failed": "outcomeFailed",
+    "interrupted": "outcomeInterrupted",
+    "unknown": "outcomeUnknown"
+  },
+  "admission": {
+    "accepted": "admissionAccepted",
+    "failed": "admissionFailed",
+    "unknown": "admissionUnknown"
+  },
+  "understandingAction": {
+    "stop-understanding": "actionStopUnderstanding",
+    "withdraw-source": "actionWithdrawSource",
+    "correct": "actionCorrect"
+  },
+  "goal": {
+    "tracking": "goalTracking",
+    "paused": "goalPaused",
+    "closed": "goalClosed"
+  },
+  "relation": {
+    "part_of": "goalPart",
+    "supports": "goalSupports",
+    "derived_from": "goalDerived"
+  },
+  "claim": {
+    "user_statement": "understandingLiteral",
+    "inference": "understandingInference",
+    "open_question": "understandingQuestion"
+  }
+};
+// Free text (including reasons, provenance and authored content) is not passed here.
+export function presentationLabel(group, value, t) {
+  const entries = Object.hasOwn(presentationKeys, group) ? presentationKeys[group] : null;
+  return t(entries && Object.hasOwn(entries, value) ? entries[value] : 'presentationUnknown');
+}

package/src/main-session.mjs

@@ -0,0 +1,7 @@
+// Browsing checks the currently mounted main Agent, never historical work or
+// client-supplied preset labels. This must not wake or bind a cold session.
+export function currentMainAgent({ agents, agentPresets }, sessionId) {
+  const agent = agents?.get(sessionId);
+  return agent && agent.id === sessionId && agentPresets?.composedPreset(agent.ctx) === 'arcfold-main'
+    ? agent : null;
+}

package/src/method-source.mjs

@@ -0,0 +1,82 @@
+import { requireViewScope, viewScopeFields } from './browse-source.mjs';
+const CHANNEL = '/api';
+export async function callMethod(rpc, endpoint, payload, signal) {
+  const result = await rpc.call(CHANNEL, `arcfoldMethods/${endpoint}`, { args: { request: payload } }, signal);
+  if (result?.ok !== true) throw Object.assign(new Error(result?.error?.message || '方法请求未完成。'),
+    { code: result?.error?.code || 'method_request_failed', remote: true });
+  return result.value;
+}
+
+// One UI-owned read cache, not a second business queue. It exists only while observed.
+export function createMethodSource({ rpc, sessionId, viewScope, subscribeReset, intervalMs = 5000 }) {
+  viewScopeFields(viewScope);
+  let snapshot = { loading: true, error: null, items: [], total: 0, decisionCount: 0,
+    nextOffset: null, offset: 0, unreadCount: 0, readEpoch: 0 };
+  const listeners = new Set(), reads = new Set();
+  let generation = 0, controller, timer, reset, disposed = false;
+  const publish = value => { snapshot = { ...snapshot, ...value }; for (const listener of listeners) listener(); };
+  const scope = () => viewScope === undefined ? {} : { sessionId, ...viewScopeFields(viewScope) };
+  const cancelled = () => Object.assign(new Error('查看范围已变化，请重新打开方法。'), { code: 'method_read_cancelled' });
+  function invalidateReads() {
+    controller?.abort(); generation++;
+    for (const read of reads) read.abort();
+    publish({ loading: true, error: null, items: [], total: 0, decisionCount: 0,
+      nextOffset: null, offset: 0, unreadCount: 0, readEpoch: snapshot.readEpoch + 1 });
+  }
+  async function refresh(offset = snapshot.offset) {
+    if (disposed) return;
+    controller?.abort(); controller = new AbortController();
+    const current = ++generation, signal = controller.signal;
+    try {
+      const cards = await callMethod(rpc, 'cards', { offset, limit: 20, ...scope() }, signal);
+      if (current !== generation || signal.aborted || disposed) return;
+      publish({ loading: false, error: null, items: cards.items, total: cards.total,
+        decisionCount: cards.decisionCount, nextOffset: cards.nextOffset, offset, unreadCount: cards.unreadCount });
+    } 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);
+        reset = subscribeReset(() => { invalidateReads(); void refresh(0); });
+      }
+      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(methodId, offset = 0) {
+      if (disposed) throw cancelled();
+      const read = new AbortController(), epoch = snapshot.readEpoch; reads.add(read);
+      try {
+        const value = await callMethod(rpc, 'cardDetails', { methodId, offset, limit: 20, ...scope() }, read.signal);
+        if (disposed || read.signal.aborted || epoch !== snapshot.readEpoch) throw cancelled();
+        return value;
+      } finally { reads.delete(read); }
+    },
+    async acknowledge(notificationId) {
+      const result = await callMethod(rpc, 'acknowledge', { notificationId });
+      await refresh(); return result;
+    },
+    async decide(request) {
+      const result = await callMethod(rpc, 'decide', request);
+      await refresh(); return result;
+    },
+    dispose() { disposed = true; stop(); listeners.clear(); },
+  };
+}