dsh-ops 0.2.3 → 0.2.5-beta.1

package/lib/runtime-pool.js

@@ -0,0 +1,42 @@
+/** One plugin-owned FastCtx connection shared by independently toggled components. */
+import { McpStdioClient } from './handshake.js'
+const pools = new WeakMap()
+export async function acquireRuntime(ctx, runtime, env) {
+  const root = ctx.root
+  let pool = pools.get(root)
+  if (!pool) { pool = { clients: new Map(), closing: Promise.resolve() }; pools.set(root, pool) }
+  await pool.closing
+  let entry = pool.clients.get(runtime.file)
+  if (!entry) {
+    const client = McpStdioClient.start({ file: runtime.file, args: ['serve', '--enable-shell'], env, timeoutMs: 60000 })
+    entry = { client, refs: 0, ready: undefined }
+    pool.clients.set(runtime.file, entry)
+    entry.ready = (async () => {
+      try {
+        const handshake = await client.initialize('dsh-ops-components')
+        const tools = await client.listTools()
+        return { client, handshake, tools }
+      } catch (error) {
+        if (pool.clients.get(runtime.file) === entry) pool.clients.delete(runtime.file)
+        await client.close()
+        throw error
+      }
+    })()
+    void client.exited.then(() => { if (pool.clients.get(runtime.file) === entry) pool.clients.delete(runtime.file) })
+  }
+  entry.refs += 1
+  let released = false
+  const release = async () => {
+    if (released) return
+    released = true
+    entry.refs -= 1
+    if (!entry.refs) {
+      if (pool.clients.get(runtime.file) === entry) pool.clients.delete(runtime.file)
+      const closing = pool.closing.then(() => entry.client.close())
+      pool.closing = closing.catch(() => {})
+      await closing
+    }
+  }
+  try { return { ...await entry.ready, release } }
+  catch (error) { await release(); throw error }
+}

package/lib/session-pwsh.js

@@ -0,0 +1,31 @@
+/** A reversible runtime-only config overlay; never edits profile files or services. */
+export function mountBundledPwsh(ctx, shells) {
+  if (!shells.pwsh.available || process.platform !== 'win32') return
+  ctx.inject(['loader'], loaderCtx => {
+    const loader = loaderCtx.get('loader')
+    const matches = entry => entry?.options?.id === 'pwsh-sandbox'
+      && entry.options.name === '@deepseek-ai/dsh-pwsh-sandbox'
+    const refresh = () => {
+      for (const entry of loader.entries()) {
+        if (matches(entry) && entry.fiber?.state === 2) {
+          // Public Fiber.update with noSave recomputes from the owner's latest
+          // raw config. No stored config, volatile reference, or method is changed.
+          entry.fiber.update(entry.options.config, true)
+        }
+      }
+    }
+    const unhook = loaderCtx.on('internal/config', function (_raw, next) {
+      const config = next()
+      if (!matches(this.entry) || this.parent?.fiber?.entry === this.entry) return config
+      return { ...config, pwshPath: shells.pwsh.file }
+    }, { global: true, prepend: true })
+    let stopped = false
+    loaderCtx.effect(() => () => {
+      if (stopped) return
+      stopped = true
+      unhook()
+      refresh()
+    }, 'dsh-ops: restore owning PowerShell executor config')
+    refresh()
+  })
+}

package/lib/tools.js

@@ -23,6 +23,8 @@ import { McpStdioClient } from './handshake.js'
 import { FILE_TOOLS, SHELL_TOOLS, publicToolName } from './policy.js'
 import { projectTool } from './presentation.js'
 import { cleanBackground, jobEntries, startedJob } from './jobs.js'
+import { acquireRuntime } from './runtime-pool.js'
+import { resolveShells } from './shells.js'
 
 /** Deadline for one connection attempt: spawn, initialize, and `tools/list`. */
 const CONNECT_TIMEOUT_MS = 60_000
@@ -216,10 +218,16 @@ export class FastCtxTools {
    * @param {{file: string, source: string, version: string}} options.runtime - the resolved FastCtx executable.
    * @param {(message: string, level?: string) => void} [options.report] - where asynchronous events are reported.
    */
-  constructor({ ctx, config, runtime, report }) {
+  constructor({ ctx, config, runtime, report, fileTools = true, commandTools = SHELL_TOOLS, shared = false }) {
     this.ctx = ctx
     this.config = config
     this.runtime = runtime
+    this.fileTools = fileTools
+    this.commandTools = commandTools
+    this.shared = shared
+    this.leases = new Map()
+    this.pendingCalls = new Set()
+    this.shuttingDown = false
     this.report = report ?? (() => {})
     /** The live connection, or undefined while the surface is down. */
     this.client = undefined
@@ -282,7 +290,7 @@ export class FastCtxTools {
     if (!entry?.ctx) return
     for (const dispose of entry.disposers) dispose()
     entry.disposers = []
-    if (this.stopped) return
+    if (this.stopped || this.shuttingDown) return
     if (!this.shellAllowed(agent.session)) {
       // A child must not inherit an authorized ancestor's command surface.
       const names = (this.ctx.get('tools')?.schemas(agent) ?? []).map(tool => tool.name)
@@ -293,8 +301,8 @@ export class FastCtxTools {
       }
       return
     }
-    const commandTools = this.tools.filter(tool => SHELL_TOOLS.includes(tool.name))
-    if (commandTools.length !== SHELL_TOOLS.length) return
+    const commandTools = this.tools.filter(tool => this.commandTools.includes(tool.name))
+    if (commandTools.length !== this.commandTools.length) return
     try {
       for (const tool of commandTools) {
         entry.disposers.push(entry.ctx.tools.register(toolDefinition({
@@ -367,6 +375,20 @@ export class FastCtxTools {
    * @returns {Promise<void>} resolves once the child is gone.
    */
   async stop() {
+    this.shuttingDown = true
+    this.refreshAgents()
+    // Drain launches before killing only this component's owned jobs. Closing
+    // FastCtx alone does not stop its durable supervisors.
+    await Promise.allSettled([...this.pendingCalls])
+    const cleanupClient = this.client
+    if (cleanupClient) {
+      for (const ids of this.ownedJobs.values()) for (const job_id of ids) {
+        try {
+          const result = await cleanupClient.callTool('job_kill', { job_id }, { timeoutMs: 15000 })
+          if (result?.isError) this.report(`dsh-ops: owned job ${job_id} could not be stopped during component shutdown.`, 'warn')
+        } catch (error) { this.report(`dsh-ops: owned job ${job_id} shutdown failed: ${messageOf(error)}`, 'warn') }
+      }
+    }
     this.stopped = true
     if (this.timer !== undefined) {
       clearTimeout(this.timer)
@@ -380,7 +402,14 @@ export class FastCtxTools {
     this.tools = []
     this.ownedJobs.clear()
     await Promise.all([...this.agents.keys()].map(agent => this.detachAgent(agent)))
-    if (client !== undefined) await client.close()
+    if (client !== undefined) await this.#release(client)
+  }
+
+  async #release(client) {
+    const lease = this.leases.get(client)
+    this.leases.delete(client)
+    if (lease) await lease.release()
+    else if (!this.shared) await client.close()
   }
 
   /**
@@ -388,7 +417,16 @@ export class FastCtxTools {
    * @returns {Promise<void>} resolves once the generation is live.
    */
   async #connect() {
-    const client = McpStdioClient.start({
+    let lease
+    if (this.shared) {
+      const env = childEnv()
+      const bash = resolveShells(this.config).bash
+      if (bash.available) env.FASTCTX_BASH = bash.file
+      lease = await acquireRuntime(this.ctx, this.runtime, env)
+      if (this.shuttingDown || this.stopped) { await lease.release(); throw new StoppedError() }
+      this.leases.set(lease.client, lease)
+    }
+    const client = lease?.client ?? McpStdioClient.start({
       file: this.runtime.file,
       args: serverArgs(this.config.enableShellTools),
       env: childEnv(),
@@ -401,9 +439,9 @@ export class FastCtxTools {
     // already replaced or abandoned.
     void client.exited.then(({ code, signal, error }) => this.#onExit(client, code, signal, error))
     try {
-      const handshake = await client.initialize('dsh-ops')
-      const tools = await client.listTools()
-      if (this.stopped || client !== this.client) throw new StoppedError()
+      const handshake = lease?.handshake ?? await client.initialize('dsh-ops')
+      const tools = lease?.tools ?? await client.listTools()
+      if (this.stopped || this.shuttingDown || client !== this.client) throw new StoppedError()
       this.ownedJobs.clear()
       this.#publish(tools)
       this.serverInfo = handshake?.serverInfo
@@ -411,7 +449,7 @@ export class FastCtxTools {
       this.serverInstructions = ''
       this.connectedAt = Date.now()
     } catch (error) {
-      await client.close()
+      await this.#release(client)
       if (this.client === client) this.client = undefined
       throw error
     }
@@ -426,7 +464,8 @@ export class FastCtxTools {
    * @returns {void}
    */
   #onExit(client, code, signal, error) {
-    if (this.stopped || client !== this.client) return
+    if (this.stopped || this.shuttingDown || client !== this.client) return
+    void this.#release(client)
     this.client = undefined
     this.ownedJobs.clear()
     this.tools = []
@@ -449,7 +488,7 @@ export class FastCtxTools {
   #scheduleReconnect() {
     // One pending timer at a time: a crash and a failed first connect can both
     // land here, and two loops would double every later attempt.
-    if (this.stopped || this.timer !== undefined) return
+    if (this.stopped || this.shuttingDown || this.timer !== undefined) return
     // A connection that stayed up long enough closed the previous outage.
     if (this.connectedAt !== undefined && Date.now() - this.connectedAt >= RECONNECT.maxDelayMs) {
       this.attempts = 0
@@ -486,12 +525,12 @@ export class FastCtxTools {
    * @returns {Promise<void>} resolves once this attempt settled.
    */
   async #reconnect() {
-    if (this.stopped) return
+    if (this.stopped || this.shuttingDown) return
     try {
       await this.#connect()
       this.report(`dsh-ops: ${this.#describe()} reconnected with ${this.names().length} tool(s).`)
     } catch (error) {
-      if (this.stopped) return
+      if (this.stopped || this.shuttingDown) return
       this.report(
         `dsh-ops: FastCtx reconnect attempt ${this.attempts}/${RECONNECT.maxAttempts} `
         + `failed (${messageOf(error)}).`,
@@ -521,7 +560,7 @@ export class FastCtxTools {
         throw new Error(`${this.#describe()} listed the tool "${String(tool?.name)}" more than once`)
       }
       seen.add(name)
-      if (!FILE_TOOLS.includes(tool.name)) continue
+      if (!this.fileTools || !FILE_TOOLS.includes(tool.name)) continue
       definitions.push(toolDefinition({
         tool,
         call: (args, exec) => this.#call(tool.name, args, exec),
@@ -556,7 +595,15 @@ export class FastCtxTools {
    * @param {{signal?: AbortSignal, agent?: {session?: object}}} [exec] - the host execution context.
    * @returns {Promise<{content: unknown[], structuredContent?: unknown}>} the canonical value.
    */
-  async #call(rawName, args, exec) {
+  #call(rawName, args, exec) {
+    if (this.shuttingDown || this.stopped) return Promise.reject(new Error('This dsh-ops component is shutting down.'))
+    const call = this.#callActive(rawName, args, exec)
+    this.pendingCalls.add(call)
+    void call.then(() => this.pendingCalls.delete(call), () => this.pendingCalls.delete(call))
+    return call
+  }
+
+  async #callActive(rawName, args, exec) {
     const label = publicToolName(rawName)
     const session = exec?.agent?.session
     if (SHELL_TOOLS.includes(rawName) && !this.shellAllowed(session)) {
@@ -569,6 +616,7 @@ export class FastCtxTools {
         throw new Error('This is an image; use host read_image.')
       }
     }
+    if (rawName === 'run_background') args = { ...args, cwd: args?.cwd ?? session?.header?.cwd }
     const client = this.client
     if (client === undefined) {
       // A dead server must be an immediate, explicit failure rather than a

package/node_modules/@dsh-ops/auto-compact/LICENSE

@@ -0,0 +1,30 @@
+MIT License
+
+Copyright (c) 2026 T-Auto and the dsh-ops contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+-------------------------------------------------------------------------------
+
+This MIT license covers the dsh-ops plugin: everything in this repository
+except `vendor/fastctx/`, which is FastCtx under the Apache License 2.0. The
+distribution as a whole is therefore licensed under the composite
+`MIT AND Apache-2.0`. See `NOTICE` for the full statement and the attribution
+FastCtx requires, and `vendor/fastctx/LICENSE-APACHE` for the Apache License
+2.0 text.

package/node_modules/@dsh-ops/auto-compact/README.md

@@ -0,0 +1,23 @@
+# @dsh-ops/auto-compact
+
+Internal, bundled companion of dsh-ops. It adds one independently toggled row to
+**Plugins → dsh-ops → Included components**, not a second marketplace bundle.
+The package-root entry is required by DSH rc.2's browser module discovery; plugin
+subpaths are not browser entry points. No separate installation is required.
+
+Defaults: threshold 50% (integer 1–99), cooldown 120s (30–3600), timeout 120s
+(10–600). Configuration belongs to this row and uses host profile settings with
+revision fencing and restore defaults. The policy calls the same public idle
+maintenance API as `/compact` only above the rounded Web context percentage and
+after a non-cancelled turn. Running tools are not interrupted. No new model-facing
+tool, polling, or host auto-policy modification is introduced.
+
+One owned operation at a time, cooldown, unchanged-surface suppression and
+abort/drain teardown bound work. Commit/save failures suspend this session until
+component reload and require inspection. Timeouts rely on cooperative cancellation.
+Summarization may call the host's configured model and incur cost; it is not
+lossless. Missing samples/capacity and busy admission skip work.
+
+This companion is carried by the dsh-ops 0.2.5-beta.1 prerelease candidate, not the
+stable 0.2.4. Check registry metadata for publication status. See the main repository's
+`docs/auto-compact.md` for safety limits and manual acceptance requirements.

package/node_modules/@dsh-ops/auto-compact/lib/client.js

@@ -0,0 +1,79 @@
+/** Browser artifact in the host's closure-factory module format; no globals except its loader. */
+window.__ModuleLoader__.load({ id: '@dsh-ops/auto-compact', factory: require => {
+  const { createElement: h, useState, useEffect, useRef } = require('react')
+  const NS = 'dshOps.autoCompact'
+  const dictionaries = {
+    en: {
+      title: 'Settings', threshold: 'Context threshold (%)', cooldown: 'Cooldown (seconds)', timeout: 'Compaction timeout (seconds)',
+      save: 'Save', reset: 'Restore defaults', saved: 'Saved', failed: 'Not saved. Configuration may have changed; reload and retry.',
+      unavailable: 'Enable this component to configure it. This client must have host settings write access.',
+      hint: 'When the Web context meter is strictly above the threshold, compact at the next idle boundary using the same service as /compact. Running tools are not interrupted. Summarization may call your configured model and incur cost. No extra model-facing tool is added.',
+      invalid: 'Enter integers: threshold 1–99, cooldown 30–3600, timeout 10–600.',
+    },
+    zh: {
+      title: '设置', threshold: '上下文阈值（%）', cooldown: '冷却时间（秒）', timeout: '压缩超时（秒）',
+      save: '保存', reset: '恢复默认', saved: '已保存', failed: '未保存，配置可能已变化，请重新加载后重试。',
+      unavailable: '请先启用此组件；当前客户端还需具有宿主设置写入权限。',
+      hint: 'Web 上下文占用严格高于阈值后，在下一次空闲边界调用与 /compact 相同的服务；不会打断正在运行的工具。摘要可能调用已配置模型并产生费用，不额外增加模型可调用工具。',
+      invalid: '请输入整数：阈值 1–99，冷却 30–3600 秒，超时 10–600 秒。',
+    },
+  }
+  const defaults = { thresholdPercent: 50, cooldownSeconds: 120, timeoutSeconds: 120 }
+  const fields = [
+    ['thresholdPercent', 'threshold', 1, 99],
+    ['cooldownSeconds', 'cooldown', 30, 3600],
+    ['timeoutSeconds', 'timeout', 10, 600],
+  ]
+  function Settings({ view, form, t }) {
+    const [draft, setDraft] = useState(defaults)
+    const [revision, setRevision] = useState(undefined)
+    const [busy, setBusy] = useState(false)
+    const [message, setMessage] = useState('')
+    const alive = useRef(false)
+    useEffect(() => { alive.current = true; return () => { alive.current = false } }, [])
+    useEffect(() => {
+      if (form?.state.status === 'ready') {
+        setDraft({ ...defaults, ...form.state.value })
+        setRevision(form.state.revision)
+      }
+    }, [form?.state.revision, form?.state.status])
+    if (view === 'summary') return t('hint')
+    const writable = form?.state.status === 'ready' && form.state.writable && form.state.mode === 'host'
+    async function save(reset) {
+      if (!writable || busy || revision === undefined) return
+      if (!reset && fields.some(([key, , min, max]) => !Number.isInteger(Number(draft[key])) || String(draft[key]).trim() === '' || Number(draft[key]) < min || Number(draft[key]) > max)) {
+        setMessage(t('invalid')); return
+      }
+      setBusy(true); setMessage('')
+      try {
+        const ops = fields.map(([key]) => reset
+          ? { op: 'unset', path: [key] }
+          : { op: 'set', path: [key], value: Number(draft[key]) })
+        const ok = await form.mutate(ops, revision)
+        if (alive.current) setMessage(t(ok ? 'saved' : 'failed'))
+      } catch { if (alive.current) setMessage(t('failed')) }
+      finally { if (alive.current) setBusy(false) }
+    }
+    return h('section', { 'data-dsh-ops-auto-compact-settings': true },
+      h('h4', null, t('title')),
+      h('p', null, t('hint')),
+      !writable ? h('p', { role: 'status' }, t('unavailable')) : null,
+      ...fields.map(([key, label, min, max]) => h('label', { key, style: { display: 'block', marginBottom: 12 } },
+        t(label), ' ', h('input', {
+          type: 'number', min, max, step: 1, value: draft[key], disabled: !writable || busy,
+          onChange: event => setDraft(current => ({ ...current, [key]: event.target.value })),
+        }))),
+      h('button', { type: 'button', disabled: !writable || busy, onClick: () => save(false) }, t('save')), ' ',
+      h('button', { type: 'button', disabled: !writable || busy, onClick: () => save(true) }, t('reset')),
+      h('p', { role: 'status' }, message))
+  }
+  return {
+    inject: ['slots', 'locale'],
+    apply(ctx) {
+      ctx.effect(() => ctx.get('locale').register(NS, dictionaries), 'dsh-ops settings locales')
+      ctx.get('slots').inject('plugins.row.config', () => ctx.get('slots').register({
+        name: 'plugins.row.config', key: 'dsh-ops#dsh-ops-auto-compact', locale: NS,
+      }, Settings))
+    },
+  }
+} })

package/node_modules/@dsh-ops/auto-compact/lib/config.js

@@ -0,0 +1,60 @@
+/** Dependency-free strict settings and structural host form descriptor. */
+export const AUTO_COMPACT_DEFAULTS = Object.freeze({ thresholdPercent: 50, cooldownSeconds: 120, timeoutSeconds: 120 })
+const LIMITS = Object.freeze({ thresholdPercent: [1, 99], cooldownSeconds: [30, 3600], timeoutSeconds: [10, 600] })
+const WRITE = Symbol.for('cosmokit.volatile.write')
+
+export function resolveAutoCompactConfig(input = {}) {
+  if (input === null || typeof input !== 'object' || Array.isArray(input)
+    || ![Object.prototype, null].includes(Object.getPrototypeOf(input))) {
+    throw new TypeError('dsh-ops auto-compact config must be a plain object')
+  }
+  for (const key of Object.keys(input)) {
+    if (!Object.hasOwn(LIMITS, key)) throw new TypeError(`dsh-ops auto-compact: unknown config key ${key}`)
+  }
+  return Object.fromEntries(Object.entries(AUTO_COMPACT_DEFAULTS).map(([key, fallback]) => {
+    const raw = input[key]
+    const value = raw !== null && typeof raw === 'object' && WRITE in raw ? raw.get() : raw === undefined ? fallback : raw
+    const [min, max] = LIMITS[key]
+    if (!Number.isInteger(value) || value < min || value > max) {
+      throw new TypeError(`dsh-ops auto-compact: ${key} must be an integer between ${min} and ${max}`)
+    }
+    return [key, value]
+  }))
+}
+
+/**
+ * Standard Schema validation plus a serializable structural descriptor, not a
+ * Schemastery instance or vendor impersonation. The host rehydrates with its OWN
+ * library. No loading-time host values are imported. Live references implement
+ * the shared cosmokit.volatile.write protocol and are validated before updates.
+ */
+export function createAutoCompactConfigSchema() {
+  const dict = Object.fromEntries(Object.entries(AUTO_COMPACT_DEFAULTS).map(([key, value]) => [key, {
+    type: 'number',
+    meta: { default: value, min: LIMITS[key][0], max: LIMITS[key][1], step: 1, volatile: true },
+    toJSON() { return { type: this.type, meta: { ...this.meta } } },
+  }]))
+  return {
+    type: 'object', meta: { default: {} }, dict,
+    '~standard': {
+      version: 1, vendor: 'dsh-ops',
+      validate(input) {
+        try {
+          const value = Object.fromEntries(Object.entries(resolveAutoCompactConfig(input)).map(([key, initial]) => {
+            let current = initial
+            return [key, Object.freeze({ get: () => current, [WRITE]: next => { current = next } })]
+          }))
+          return { value }
+        } catch (error) { return { issues: [{ message: error.message }] } }
+      },
+    },
+    toJSON() {
+      const refs = { 0: { type: 'object', meta: { default: {} }, dict: {} } }
+      Object.entries(dict).forEach(([key, node], index) => {
+        refs[0].dict[key] = index + 1
+        refs[index + 1] = { type: node.type, meta: { ...node.meta } }
+      })
+      return { uid: 0, refs }
+    },
+  }
+}

package/node_modules/@dsh-ops/auto-compact/lib/index.js

@@ -0,0 +1,132 @@
+/** Idle-only policy over the same public compaction seam as /compact. */
+import { createAutoCompactConfigSchema, resolveAutoCompactConfig } from './config.js'
+
+export const name = 'dsh-ops-auto-compact'
+export const inject = ['compaction', 'sessionProjections']
+export const Config = createAutoCompactConfigSchema()
+
+/** Match the Web context meter; absent/invalid samples never trigger work. */
+export function contextPercent(pressure) {
+  const used = pressure?.projectedTokens ?? pressure?.pressureTokens
+  const capacity = pressure?.contextWindow
+  if (!Number.isFinite(used) || used < 0 || !Number.isFinite(capacity) || capacity <= 0) return null
+  return Math.min(100, Math.round(used / capacity * 100))
+}
+
+/** Surface changes, not compaction bookkeeping, permit a fresh attempt. */
+function surfaceKey(session) {
+  return JSON.stringify([session.surface.contentGeneration, session.surface.nodes])
+}
+
+/** Bounded, event-driven supervisor. It never publishes a model-callable tool. */
+export function createAutoCompactor(ctx, rawConfig, {
+  now = Date.now, setTimer = setTimeout, clearTimer = clearTimeout,
+} = {}) {
+  const states = new WeakMap()
+  const active = new Map()
+  const disposedAgents = new WeakSet()
+  let closed = false
+  // One summary at a time for this component, across all sessions.
+  let globalNextAt = 0
+
+  function check(agent) {
+    if (closed || disposedAgents.has(agent) || agent.status !== 'idle' || active.size > 0) return
+    let config, percent, key
+    try {
+      config = resolveAutoCompactConfig(rawConfig)
+      percent = contextPercent(ctx.get('sessionProjections').snapshot(agent.session, ['contextPressure']).values.contextPressure)
+      key = surfaceKey(agent.session)
+    } catch {
+      // No guessed capacity, no admission when a required service disappears.
+      return
+    }
+    if (percent === null || percent <= config.thresholdPercent) return
+    const state = states.get(agent.session)
+    const time = now()
+    if (time < globalNextAt || time < (state?.nextAt ?? 0)
+      || state?.blocked
+      || state?.key === key && state.threshold === config.thresholdPercent) return
+
+    const controller = new AbortController()
+    const slot = { controller, done: undefined }
+    // Install before calling compactNow: service admission may emit synchronously.
+    active.set(agent, slot)
+    states.set(agent.session, { key, threshold: config.thresholdPercent, nextAt: time + config.cooldownSeconds * 1000 })
+    globalNextAt = time + config.cooldownSeconds * 1000
+    const timer = setTimer(() => controller.abort(new Error('Automatic compaction timed out')), config.timeoutSeconds * 1000)
+    timer.unref?.()
+    let blocked = false
+    slot.done = (async () => {
+      try {
+        const result = await ctx.get('compaction').compactNow(agent, controller.signal)
+        if (result !== null) ctx.logger.info('dsh-ops auto-compact: compacted idle session history')
+      } catch (error) {
+        const code = error?.code
+        if (code === 'commit' || code === 'persistence') {
+          blocked = true
+          ctx.logger.warn('dsh-ops auto-compact: session requires inspection after a commit/save failure; automatic compaction is suspended until this component is reloaded')
+        } else if (!controller.signal.aborted && code !== 'busy' && code !== 'cancelled') {
+          // Do not log history, provider errors, paths or credentials.
+          ctx.logger.warn('dsh-ops auto-compact: compaction failed; automatic retry is backed off')
+        }
+      } finally {
+        clearTimer(timer)
+        // Suppress retries against our own replacement or bookkeeping records.
+        try {
+          states.set(agent.session, {
+            key: surfaceKey(agent.session), threshold: config.thresholdPercent, blocked,
+            nextAt: now() + config.cooldownSeconds * 1000,
+          })
+        } catch { /* disposed session */ }
+        globalNextAt = now() + config.cooldownSeconds * 1000
+        if (active.get(agent) === slot) active.delete(agent)
+      }
+    })()
+  }
+
+  function retire(agent) {
+    disposedAgents.add(agent)
+    active.get(agent)?.controller.abort(new Error('Agent disposed'))
+  }
+
+  async function dispose() {
+    closed = true
+    const slots = [...active.values()]
+    for (const slot of slots) slot.controller.abort(new Error('Automatic compaction component disabled'))
+    await Promise.allSettled(slots.map(slot => slot.done))
+  }
+  return { check, retire, dispose }
+}
+
+/** Keep this plugin's validated live references stable through Fiber.update. */
+export function installLiveConfigUpdates(ctx, config) {
+  ctx.on('internal/update', (candidate, _noSave, _next) => {
+    const values = resolveAutoCompactConfig(candidate)
+    const write = Symbol.for('cosmokit.volatile.write')
+    for (const [key, value] of Object.entries(values)) config[key][write](value)
+    try { ctx.emit('loader/volatile-update', Object.keys(values).map(key => [key])) }
+    catch { ctx.logger.warn('dsh-ops auto-compact: live config notification failed') }
+  })
+}
+
+/** Scoped listeners, abort and drain follow the host's teardown lifecycle. */
+export function apply(ctx, config = {}, { liveUpdates = true } = {}) {
+  resolveAutoCompactConfig(config)
+  if (liveUpdates) installLiveConfigUpdates(ctx, config)
+  const policy = createAutoCompactor(ctx, config)
+  const lastTurnSignals = new WeakMap()
+  ctx.effect(function* () {
+    yield () => policy.dispose()
+    yield ctx.on('agent/status', ({ agent, status }) => {
+      if (status === 'idle' && !lastTurnSignals.get(agent)?.aborted) policy.check(agent)
+    })
+    yield ctx.on('agent/turn-stopping', ({ agent, signal }) => {
+      lastTurnSignals.set(agent, signal)
+    })
+    yield ctx.on('agent/disposed', ({ agent }) => policy.retire(agent))
+    // Hot-enabling also covers already loaded idle sessions, without waking them.
+    ctx.inject(['agents'], inner => {
+      for (const agent of inner.get('agents').list()) policy.check(agent)
+    })
+  }, 'dsh-ops auto-compact lifecycle')
+}

package/node_modules/@dsh-ops/auto-compact/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Automatic context compaction",
+    "description": "Compact idle context above a configurable threshold (50% by default), without interrupting running tasks."
+  }
+}

package/node_modules/@dsh-ops/auto-compact/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "上下文自动压缩",
+    "description": "上下文占用高于可设置阈值（默认 50%）时，在会话空闲后自动压缩，避免打断运行中的任务。"
+  }
+}

package/node_modules/@dsh-ops/auto-compact/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@dsh-ops/auto-compact",
+  "version": "0.1.0",
+  "description": "Idle-only automatic context compaction and row settings for dsh-ops.",
+  "license": "MIT",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json"
+  },
+  "dsh": {
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-plugin-manager"
+      ]
+    }
+  },
+  "files": ["lib", "locale", "LICENSE", "README.md"],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/T-Auto/dsh-ops.git",
+    "directory": "packages/auto-compact"
+  },
+  "publishConfig": { "access": "public" }
+}