dsh-tiddlywiki 0.5.0 → 0.7.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-tiddlywiki",
-  "description": "TiddlyWiki 5 as the DSH persistent knowledge base: tiddlywiki_* agent tools (search with filters/recent/tags/batch/rename + git sync & conflict resolve), a full TiddlyWiki editor embedded in the GUI center column, a quick-note card with draft auto-save & recent-notes picker behind a single knowledge FAB, and git-based sync with auto-commit. Mounts via the official dsh plugin system — no DSH source changes.",
-  "version": "0.5.0",
+  "description": "TiddlyWiki 5 as the DSH persistent knowledge base: tiddlywiki_* agent tools (search with filters/recent/tags/batch/rename + git sync & conflict resolve), a full TiddlyWiki editor embedded in the GUI center column (same-origin proxy, works over Tailscale/LAN/domain), a quick-note card with draft auto-save & recent-notes picker behind a single knowledge FAB, and git-based sync with auto-commit. Mounts via the official dsh plugin system — no DSH source changes.",
+  "version": "0.7.2",
   "type": "module",
   "keywords": [
     "dsh",

package/src/client/note-widget.ts

@@ -634,7 +634,11 @@ export function createNoteWidget(): NoteWidgetHandle {
         }
         clearDraft()
         hideDraftBanner()
-        openEditorPopup(`${payload.twUrl}#${encodeURIComponent(payload.draftTitle)}`, payload.title ?? title)
+        // twUrl is the same-origin proxy path (e.g. /dsh-tiddlywiki/tw/);
+        // resolve it against this page's origin so the popup works from any
+        // host/domain DSH is reached on (loopback, LAN, Tailscale, HTTPS).
+        const popupUrl = `${new URL(payload.twUrl, location.origin).href}#${encodeURIComponent(payload.draftTitle)}`
+        openEditorPopup(popupUrl, payload.title ?? title)
         toast(`已在弹出窗口打开「${payload.title ?? title}」编辑器`)
       } catch (err) {
         toast(`打开失败：${err instanceof Error ? err.message : String(err)}`)

package/src/client/panel.ts

@@ -10,10 +10,13 @@
  * Toggling rides the shared PanelState; cross-plugin exclusivity rides the
  * `dsh-panel-activate` event (same protocol as dsh-taskboard).
  *
- * The iframe points DIRECTLY at the TW service (http://127.0.0.1:<port>),
- * bypassing reverse-proxy sensitivity (design doc R1 — proxy is only a
- * fallback). The panel reads /status first and only sets iframe.src when the
- * service is actually running.
+ * The iframe points at the SAME-ORIGIN TW proxy (`<origin>/dsh-tiddlywiki/tw/`,
+ * remote-access mode R1): the browser only talks to the DSH origin — which it
+ * already reaches over loopback, LAN, Tailscale, a domain or HTTPS — and DSH
+ * proxies to the loopback TW child. The panel reads /status first and only
+ * sets iframe.src when the service is actually running. Because the proxy URL
+ * is origin-relative and port-independent, a TW restart never reloads the
+ * iframe, so an in-progress edit keeps its unsaved state.
  *
  * @module dsh-tiddlywiki/client/panel
  */
@@ -76,6 +79,8 @@ interface StatusPayload {
   ok?: boolean
   status: string
   url?: string
+  /** Same-origin TW proxy path (e.g. /dsh-tiddlywiki/tw/); the iframe base. */
+  twProxy?: string
   wikiPath?: string
   error?: string
   note?: { tag?: string }
@@ -232,9 +237,18 @@ export function mountPanel(state: PanelState): () => void {
       showError('无法访问 /dsh-tiddlywiki/status')
       return
     }
-    if (payload.status === 'running' && typeof payload.url === 'string') {
+    if (payload.status === 'running') {
       refreshAttempts = 0
-      showFrame(payload.url)
+      // Same-origin proxy URL: build from the page's own origin so it works no
+      // matter which host/domain the user reached DSH on. Fall back to the
+      // legacy loopback `url` for older servers that do not send twProxy.
+      if (typeof payload.twProxy === 'string') {
+        showFrame(new URL(payload.twProxy, window.location.origin).href)
+      } else if (typeof payload.url === 'string') {
+        showFrame(payload.url)
+      } else {
+        showError('服务未返回编辑器地址')
+      }
       return
     }
     if (payload.status === 'starting') {

package/src/host/config.ts

@@ -27,6 +27,13 @@ export interface PluginConfigShape {
     showPanelStatus?: boolean
     /** 是否在界面右下角显示「同步」悬浮按钮（默认 true）。 */
     showSyncButton?: boolean
+    /**
+     * 一键发送给 Agent（TW 笔记 → DSH 会话注入）。
+     * `enabled: false` 时路由 403、TW 端按钮点击提示未启用；`token` 非空时
+     * 路由要求请求头 `x-send-to-agent-token` 与之匹配；`endpoint` 可覆盖
+     * TW 端默认的 `location.origin + /dsh-tiddlywiki`。
+     */
+    sendToAgent?: { enabled?: boolean; endpoint?: string; token?: string }
   }
   uiLanguage?: string
   [key: string]: unknown

package/src/host/routes.ts

@@ -7,20 +7,24 @@
  * | /dsh-tiddlywiki/note      | POST   | quick-note → independent tiddler         |
  * | /dsh-tiddlywiki/restart   | POST   | one-click retry/restart of the TW child  |
  * | /dsh-tiddlywiki/api/*     | any    | passthrough to the TW service (JSON)     |
+ * | /dsh-tiddlywiki/tw/*      | any    | SAME-ORIGIN TW proxy (index + files + TiddlyWeb API) |
  *
- * Matching is exact-over-prefix, so the exact routes win and the `/api`
- * prefix catches the rest. Client calls are same-origin (the DSH web server),
- * so no CORS is involved.
+ * Matching is exact-over-prefix, so the exact routes win and the `/api` /
+ * `/tw` prefixes catch the rest. Client calls are same-origin (the DSH web
+ * server), so no CORS is involved. The `/tw` proxy is the remote-access
+ * bridge: it serves the ENTIRE TW frontend to the browser through the DSH
+ * origin (see TW_PROXY_PATH in wiki.ts), so the embedded editor works no
+ * matter which host/domain the user reaches DSH on.
  *
  * @module dsh-tiddlywiki/host/routes
  */
-import type { IncomingMessage, ServerResponse } from 'node:http'
+import type { IncomingHttpHeaders, IncomingMessage, ServerResponse } from 'node:http'
 import { mkdir, writeFile, access } from 'node:fs/promises'
 import { basename, extname, join } from 'node:path'
 import type { TiddlyWebClient } from './tw-api.ts'
 import type { WikiServer } from './wiki.ts'
 import type { GitFace } from './git.ts'
-import { PATH_PREFIX } from './wiki.ts'
+import { PATH_PREFIX, TW_PROXY_PREFIX, TW_PROXY_PATH } from './wiki.ts'
 
 export const ROUTE_PREFIX = PATH_PREFIX
 
@@ -43,6 +47,32 @@ export interface WebServerFace {
   register(route: { kind: 'exact' | 'prefix'; path: string; handler: (req: IncomingMessage, res: ServerResponse) => void }): () => void
 }
 
+/**
+ * Structural face over the DSH `sessionController` service (a subset of
+ * dsh-api-session-controller). Only the methods the agent-send routes need are
+ * declared; the runtime instance is a real Service, never inspected data.
+ */
+export interface SessionControllerFace {
+  prompt(
+    request: { requestId: string; sessionId: string; mode: 'queue' | 'steer'; content: Array<{ type: 'text'; text: string }> },
+    signal: AbortSignal,
+  ): Promise<{ accepted: boolean }>
+  list(
+    request: { cursor?: string },
+    signal: AbortSignal,
+  ): Promise<{
+    items: Array<{
+      sessionId: string
+      updatedAt?: number
+      running?: boolean
+      blank?: boolean
+      parentSessionId?: string
+      cwd?: string
+    }>
+  }>
+  create(request: { cwd?: string; workspaceId?: string }): Promise<{ sessionId: string }>
+}
+
 /** Effective UI visibility flags returned by /status (mirror index.ts). */
 export interface UiDefaultsPublic {
   showQuickNote: boolean
@@ -58,6 +88,13 @@ export interface RouteDeps {
   noteDefaults: () => { tag: string }
   uiDefaults: () => UiDefaultsPublic
   getWikiPath: () => string
+  /** Optional DSH sessionController service (agent-send routes only); resolved
+   *  lazily per request because it may register after webServer appears. */
+  getSessionController: () => SessionControllerFace | undefined
+  /** Whether the one-click send-to-agent feature is enabled (config switch). */
+  sendToAgentEnabled: () => boolean
+  /** Optional shared token that must match `x-send-to-agent-token` when set. */
+  sendToAgentToken: () => string
 }
 
 function readBody(req: IncomingMessage, limit = MAX_BODY_BYTES): Promise<string> {
@@ -97,6 +134,26 @@ function readBodyBuffer(req: IncomingMessage, limit = MAX_UPLOAD_BYTES): Promise
   })
 }
 
+/** Header names forwarded to the upstream TW service by the proxy routes. */
+const FORWARD_HEADER_NAMES = [
+  'accept', 'accept-encoding', 'content-type', 'cookie', 'authorization',
+  'if-none-match', 'if-modified-since', 'origin', 'referer', 'user-agent',
+] as const
+
+/** Copy a safe, string-valued subset of the request headers upstream. */
+function forwardHeaders(headers: IncomingHttpHeaders): Record<string, string> {
+  const out: Record<string, string> = {}
+  for (const name of FORWARD_HEADER_NAMES) {
+    // Index through the string index signature so known header names (typed
+    // `string`) do not hide the `string[]` repeat case via their specific
+    // property declarations.
+    const value: string | string[] | undefined = headers[name as string]
+    if (typeof value === 'string') out[name] = value
+    else if (Array.isArray(value) && value.length > 0) out[name] = value.join(', ')
+  }
+  return out
+}
+
 /**
  * Sanitize an uploaded filename into a safe bare name (no path separators,
  * no `..`, no control characters). Returns '' when nothing usable remains.
@@ -202,7 +259,116 @@ export function registerRoutes(ctx: { webServer: WebServerFace }, deps: RouteDep
     } catch {
       gitSummary = null
     }
-    json(res, { ok: true, ...view, git: gitSummary, note: { tag: deps.noteDefaults().tag }, ui: deps.uiDefaults() })
+    json(res, { ok: true, ...view, twProxy: TW_PROXY_PATH, git: gitSummary, note: { tag: deps.noteDefaults().tag }, ui: deps.uiDefaults() })
+  }
+
+  /**
+   * GET /dsh-tiddlywiki/agent/sessions — visible ordinary sessions for the TW
+   * one-click picker (excludes subagent sessions, activity-descending).
+   */
+  const handleAgentSessions = async (_req: IncomingMessage, res: ServerResponse): Promise<void> => {
+    try {
+      const sc = deps.getSessionController()
+      if (sc === undefined) {
+        json(res, { ok: false, error: 'session service unavailable' }, 503)
+        return
+      }
+      const list = await sc.list({}, AbortSignal.timeout(10_000))
+      const items = (list.items ?? [])
+        .filter((s) => s.parentSessionId === undefined)
+        .map((s) => ({
+          sessionId: s.sessionId,
+          cwd: s.cwd ?? null,
+          running: !!s.running,
+          blank: !!s.blank,
+          updatedAt: s.updatedAt ?? 0,
+        }))
+        .sort((a, b) => b.updatedAt - a.updatedAt)
+      json(res, { ok: true, items })
+    } catch (err) {
+      json(res, { ok: false, error: err instanceof Error ? err.message : String(err) }, 500)
+    }
+  }
+
+  /**
+   * POST /dsh-tiddlywiki/agent/send — deliver a note to one agent session as a
+   * queued user message (sessionController.prompt, the same API the GUI chat
+   * input uses). Guards: feature switch, optional shared token, body shape.
+   */
+  const handleAgentSend = async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
+    try {
+      if (!deps.sendToAgentEnabled()) {
+        json(res, { ok: false, error: 'send-to-agent is disabled' }, 403)
+        return
+      }
+      const token = deps.sendToAgentToken().trim()
+      if (token.length > 0) {
+        const got = req.headers['x-send-to-agent-token']
+        const value = typeof got === 'string' ? got : Array.isArray(got) ? got[0] ?? '' : ''
+        if (value !== token) {
+          json(res, { ok: false, error: 'unauthorized' }, 401)
+          return
+        }
+      }
+      const body = JSON.parse(await readBody(req)) as { sessionId?: unknown; text?: unknown }
+      const sessionId = typeof body.sessionId === 'string' && body.sessionId.trim().length > 0 ? body.sessionId.trim() : ''
+      const text = typeof body.text === 'string' && body.text.trim().length > 0 ? body.text.trim() : ''
+      if (sessionId.length === 0 || text.length === 0) {
+        json(res, { ok: false, error: 'sessionId and text are required' }, 400)
+        return
+      }
+      const sc = deps.getSessionController()
+      if (sc === undefined) {
+        json(res, { ok: false, error: 'session service unavailable' }, 503)
+        return
+      }
+      const requestId = `tw-send-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`
+      await sc.prompt(
+        { requestId, sessionId, mode: 'queue', content: [{ type: 'text', text }] },
+        AbortSignal.timeout(20_000),
+      )
+      json(res, { ok: true, requestId, sessionId })
+    } catch (err) {
+      json(res, { ok: false, error: err instanceof Error ? err.message : String(err) }, 500)
+    }
+  }
+
+  /**
+   * POST /dsh-tiddlywiki/agent/create — create (or adopt) one ordinary session,
+   * optionally inside a workspace path. The picker uses it for "new workspace /
+   * new session"; the created session's cwd becomes its workspace. The directory
+   * is materialised so a brand-new workspace actually exists on disk.
+   */
+  const handleAgentCreate = async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
+    try {
+      if (!deps.sendToAgentEnabled()) {
+        json(res, { ok: false, error: 'send-to-agent is disabled' }, 403)
+        return
+      }
+      const token = deps.sendToAgentToken().trim()
+      if (token.length > 0) {
+        const got = req.headers['x-send-to-agent-token']
+        const value = typeof got === 'string' ? got : Array.isArray(got) ? got[0] ?? '' : ''
+        if (value !== token) {
+          json(res, { ok: false, error: 'unauthorized' }, 401)
+          return
+        }
+      }
+      const body = JSON.parse(await readBody(req)) as { cwd?: unknown }
+      const cwd = typeof body.cwd === 'string' ? body.cwd.trim() : ''
+      const sc = deps.getSessionController()
+      if (sc === undefined) {
+        json(res, { ok: false, error: 'session service unavailable' }, 503)
+        return
+      }
+      if (cwd.length > 0) {
+        await mkdir(cwd, { recursive: true })
+      }
+      const created = await sc.create({ cwd: cwd.length > 0 ? cwd : undefined })
+      json(res, { ok: true, sessionId: created.sessionId, cwd: cwd || null })
+    } catch (err) {
+      json(res, { ok: false, error: err instanceof Error ? err.message : String(err) }, 500)
+    }
   }
 
   const handleNote = async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
@@ -241,7 +407,7 @@ export function registerRoutes(ctx: { webServer: WebServerFace }, deps: RouteDep
       const text = typeof body.text === 'string' ? body.text : ''
       const result = await openInTwEditor(client, title, text, tags)
       deps.autoCommit()
-      json(res, { ok: true, ...result, twUrl: deps.server.url })
+      json(res, { ok: true, ...result, twUrl: TW_PROXY_PATH })
     } catch (err) {
       json(res, { ok: false, error: err instanceof Error ? err.message : String(err) }, 500)
     }
@@ -426,7 +592,9 @@ export function registerRoutes(ctx: { webServer: WebServerFace }, deps: RouteDep
         ok: true,
         name: candidate,
         path: `files/${candidate}`,
-        url: `/files/${encodeURIComponent(candidate)}`,
+        // Same-origin proxy URL: the embedded TW editor resolves image links
+        // against the DSH origin, so a root-absolute `/files/...` would miss.
+        url: `${TW_PROXY_PATH}files/${encodeURIComponent(candidate)}`,
         size: buf.length,
         type: req.headers['content-type'] ?? 'application/octet-stream',
       })
@@ -465,6 +633,51 @@ export function registerRoutes(ctx: { webServer: WebServerFace }, deps: RouteDep
     }
   }
 
+  /**
+   * SAME-ORIGIN proxy /dsh-tiddlywiki/tw/<rest> → TW root /<rest>. Serves the
+   * ENTIRE TW frontend (index HTML, /files/*, the TiddlyWeb API) to the
+   * browser through the DSH origin, so the embedded editor works from any
+   * host/domain the user reaches DSH on (loopback, LAN, Tailscale, domain,
+   * HTTPS). The browser never talks to the loopback TW child directly; DSH
+   * does, on the same machine. Binary responses are buffered losslessly
+   * (arrayBuffer) — unlike the /api JSON proxy, this route must never .text().
+   */
+  const handleTwProxy = async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
+    const client = deps.getClient()
+    if (client === undefined) {
+      json(res, { ok: false, error: 'wiki service is not running' }, 503)
+      return
+    }
+    const url = new URL(req.url ?? '/', 'http://127.0.0.1')
+    const rest = url.pathname.replace(new RegExp(`^${TW_PROXY_PREFIX}(?=/|$)`), '') || '/'
+    try {
+      const method = (req.method ?? 'GET').toUpperCase()
+      const headers = forwardHeaders(req.headers)
+      // TW's CSRF gate requires X-Requested-With on writes; forward it through.
+      if (method === 'PUT' || method === 'DELETE' || method === 'POST') headers['x-requested-with'] = 'TiddlyWiki'
+      const init: RequestInit = { method, headers, signal: AbortSignal.timeout(30_000) }
+      if (method === 'PUT' || method === 'POST') init.body = await readBodyBuffer(req, MAX_UPLOAD_BYTES)
+      const upstream = await fetch(`${deps.server.url}${rest}${url.search}`, init)
+      const data = Buffer.from(await upstream.arrayBuffer())
+      const responseHeaders: Record<string, string> = {
+        'content-type': upstream.headers.get('content-type') ?? 'application/octet-stream',
+        'cache-control': upstream.headers.get('cache-control') ?? 'no-store',
+      }
+      for (const name of ['etag', 'last-modified', 'content-disposition']) {
+        const value = upstream.headers.get(name)
+        if (value !== null) responseHeaders[name] = value
+      }
+      res.writeHead(upstream.status, responseHeaders)
+      res.end(data)
+    } catch (err) {
+      if (res.headersSent) {
+        res.end()
+        return
+      }
+      json(res, { ok: false, error: err instanceof Error ? err.message : String(err) }, 502)
+    }
+  }
+
   const disposers = [
     ctx.webServer.register({ kind: 'exact', path: `${ROUTE_PREFIX}/status`, handler: (req, res) => { void handleStatus(req, res) } }),
     ctx.webServer.register({ kind: 'exact', path: `${ROUTE_PREFIX}/note`, handler: (req, res) => { void handleNote(req, res) } }),
@@ -475,7 +688,11 @@ export function registerRoutes(ctx: { webServer: WebServerFace }, deps: RouteDep
     ctx.webServer.register({ kind: 'exact', path: `${ROUTE_PREFIX}/sync`, handler: (req, res) => { void handleSync(req, res) } }),
     ctx.webServer.register({ kind: 'exact', path: `${ROUTE_PREFIX}/upload`, handler: (req, res) => { void handleUpload(req, res) } }),
     ctx.webServer.register({ kind: 'exact', path: `${ROUTE_PREFIX}/restart`, handler: (req, res) => { void handleRestart(req, res) } }),
+    ctx.webServer.register({ kind: 'exact', path: `${ROUTE_PREFIX}/agent/sessions`, handler: (req, res) => { void handleAgentSessions(req, res) } }),
+    ctx.webServer.register({ kind: 'exact', path: `${ROUTE_PREFIX}/agent/send`, handler: (req, res) => { void handleAgentSend(req, res) } }),
+    ctx.webServer.register({ kind: 'exact', path: `${ROUTE_PREFIX}/agent/create`, handler: (req, res) => { void handleAgentCreate(req, res) } }),
     ctx.webServer.register({ kind: 'prefix', path: `${ROUTE_PREFIX}/api`, handler: (req, res) => { void handleApiProxy(req, res) } }),
+    ctx.webServer.register({ kind: 'prefix', path: `${TW_PROXY_PREFIX}`, handler: (req, res) => { void handleTwProxy(req, res) } }),
   ]
   return () => {
     for (const dispose of disposers) dispose()

package/src/host/wiki.ts

@@ -30,6 +30,18 @@ import type { Readable } from 'node:stream'
 /** The DSH webserver route prefix (NOT a TW path-prefix; see module header). */
 export const PATH_PREFIX = '/dsh-tiddlywiki'
 
+/**
+ * Same-origin TW proxy route on the DSH webserver (remote-access mode, R1).
+ * The browser only ever talks to the DSH origin — which it already reaches
+ * over loopback, LAN, Tailscale, a domain or HTTPS — and DSH proxies to the
+ * loopback TW child. TW's frontend is pointed at this prefix via the
+ * `$:/config/tiddlyweb/host` tiddler so every API call stays same-origin.
+ */
+export const TW_PROXY_PREFIX = `${PATH_PREFIX}/tw`
+
+/** The proxy base path (trailing slash) handed to browsers / TW's frontend. */
+export const TW_PROXY_PATH = `${TW_PROXY_PREFIX}/`
+
 /** How long to wait for the wiki to answer /status. */
 const READY_TIMEOUT_MS = 20_000
 

package/src/index.ts

@@ -22,13 +22,13 @@ import { watch, type FSWatcher } from 'node:fs'
 import { writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { AutoCommitter, GitFace } from './host/git.ts'
-import { registerRoutes, type WebServerFace } from './host/routes.ts'
+import { registerRoutes, type SessionControllerFace, type WebServerFace } from './host/routes.ts'
 import { ConfigStore, deepMerge, type PluginConfigShape } from './host/config.ts'
 import { registerAdminRoutes, ensureLanguage, resolveTwRoot, type AdminDeps } from './host/admin.ts'
 import { seedDocNote, DOC_NOTE_TITLE } from './host/seed-notes.ts'
 import { TiddlyWebClient } from './host/tw-api.ts'
 import { registerTiddlywikiTools, type ToolsDeps } from './host/tools.ts'
-import { PATH_PREFIX, WikiServer, type WikiServerOptions } from './host/wiki.ts'
+import { PATH_PREFIX, TW_PROXY_PATH, TW_PROXY_PREFIX, WikiServer, type WikiServerOptions } from './host/wiki.ts'
 import { dshHomePath, defineTool } from './sdk.ts'
 
 /** Cordis plugin name (also the client loader id / profile row id). */
@@ -38,7 +38,7 @@ export const name = 'dsh-tiddlywiki'
 export const inject = ['tools', 'systemPrompt']
 
 /** Re-exports for the headless selftest and future consumers. */
-export { AutoCommitter, GitFace, PATH_PREFIX, TiddlyWebClient, WikiServer, dshHomePath, defineTool }
+export { AutoCommitter, GitFace, PATH_PREFIX, TW_PROXY_PATH, TW_PROXY_PREFIX, TiddlyWebClient, WikiServer, dshHomePath, defineTool }
 export { ConfigStore, deepMerge } from './host/config.ts'
 export { openInTwEditor, registerRoutes } from './host/routes.ts'
 export { registerAdminRoutes, resolveTwRoot, readWikiInfo, writeWikiInfo, bundledCatalog, ensureLanguage, normalizeThemes } from './host/admin.ts'
@@ -76,7 +76,7 @@ interface ResolvedConfig {
   port: number
   git: { autoCommit: boolean; debounceMs: number; remote: string; branch: string }
   note: { tag: string }
-  ui: { showQuickNote: boolean; showPanelStatus: boolean; showSyncButton: boolean }
+  ui: { showQuickNote: boolean; showPanelStatus: boolean; showSyncButton: boolean; sendToAgent: { enabled: boolean } }
   auth: { username?: string; password?: string }
 }
 
@@ -86,10 +86,35 @@ const DEFAULTS: ResolvedConfig = {
   port: 0,
   git: { autoCommit: true, debounceMs: 60_000, remote: '', branch: 'main' },
   note: { tag: 'inbox' },
-  ui: { showQuickNote: true, showPanelStatus: true, showSyncButton: true },
+  ui: { showQuickNote: true, showPanelStatus: true, showSyncButton: true, sendToAgent: { enabled: true } },
   auth: { username: '', password: '' },
 }
 
+/** Config tiddler steering TW's frontend API base (tiddlywebadaptor). */
+export const TW_WEB_HOST_TIDDLER = '$:/config/tiddlyweb/host'
+/** The legacy default value this plugin replaces with the same-origin proxy. */
+const TW_WEB_HOST_DEFAULT = '$protocol$//$host$/'
+
+/**
+ * Point TW's frontend at the same-origin DSH proxy (remote-access mode, R1).
+ * The tiddlywebadaptor builds every API URL from $:/config/tiddlyweb/host; its
+ * default `$protocol$//$host$/` resolves to the iframe's origin ROOT, which
+ * 404s whenever the browser is not on the same machine as TW. Written only
+ * when the tiddler is missing or still the legacy default — a user override is
+ * honored (e.g. someone who really does expose TW on a dedicated origin).
+ */
+export async function ensureTwWebHost(client: TiddlyWebClient | undefined): Promise<void> {
+  if (client === undefined) return
+  let current: string | undefined
+  try {
+    current = (await client.get(TW_WEB_HOST_TIDDLER))?.text
+  } catch {
+    current = undefined
+  }
+  if (current !== undefined && current.trim() !== TW_WEB_HOST_DEFAULT) return
+  await client.put({ title: TW_WEB_HOST_TIDDLER, text: TW_PROXY_PATH, type: 'text/plain', tags: [] })
+}
+
 /** Expand $VAR / ${VAR} / %VAR% from process.env (config uses $DSH_HOME). */
 function expandEnvPath(input: string): string {
   return input
@@ -282,6 +307,13 @@ export function apply(ctx: HostCtx, rawConfig: TiddlywikiConfig = {}): void {
     try {
       await server.start()
       await configStore.load(client())
+      // Point TW's frontend at the same-origin DSH proxy (remote-access mode):
+      // runs before git bootstrap so the config tiddler joins the first commit.
+      try {
+        await ensureTwWebHost(client())
+      } catch (err) {
+        console.warn('[dsh-tiddlywiki] ensuring $:/config/tiddlyweb/host:', err)
+      }
       // Seeds (run after the effective config is loaded):
       //  - doc note: ONE-SHOT — a fresh wiki gets the plugin guide; deleting
       //    it afterwards survives restarts (see seedDocNote).
@@ -321,6 +353,11 @@ export function apply(ctx: HostCtx, rawConfig: TiddlywikiConfig = {}): void {
   // Routes + settings-panel admin surface (lazy webServer).
   ctx.inject(['webServer'], (webCtx: HostCtx) => {
     const ws = (webCtx as unknown as { webServer: WebServerFace }).webServer
+    // sessionController is a core host service; read it LAZILY per request (via
+    // the plugin root ctx) because it may be registered after webServer, and the
+    // agent routes must work whenever a request actually arrives.
+    const getSessionController = (): SessionControllerFace | undefined =>
+      ctx.get('sessionController') as SessionControllerFace | undefined
     const disposeRoutes = registerRoutes({ webServer: ws }, {
       server,
       getClient: client,
@@ -329,6 +366,12 @@ export function apply(ctx: HostCtx, rawConfig: TiddlywikiConfig = {}): void {
       noteDefaults: () => ({ tag: effectiveNoteTag() }),
       uiDefaults: () => effectiveUi(),
       getWikiPath: () => wikiPath,
+      getSessionController,
+      sendToAgentEnabled: () => eff().ui?.sendToAgent?.enabled !== false,
+      sendToAgentToken: () => {
+        const token = eff().ui?.sendToAgent?.token
+        return typeof token === 'string' ? token : ''
+      },
     })
     const adminDeps: AdminDeps = {
       server,