import { Context, Service } from '@deepseek-ai/cordis'declare module '@deepseek-ai/cordis' {  interface Context {    myService: MyService   // 让 ctx.myService 有类型  }}export class MyService extends Service {  static inject = ['sessions']  // 服务自己也可以依赖别的服务  constructor(ctx: Context) {    super(ctx, 'myService')     // 注册名称，其他插件按这个名找  }  async summarize(sessionId: string): Promise<string> {    return '...'                // 真实逻辑：读会话、调 llm、返回摘要  }}export async function apply(ctx: Context) {  await ctx.plugin(MyService)}

export const inject = ['myService']export function apply(ctx: Context) {  // 能走到这里，说明 myService 已经就绪  ctx.myService.summarize('some-session-id')}

export class Logger extends Service {  get [Service.invoke]() {    return (msg: string) => this.log(msg)  }  log(msg: string) { /* ... */ }}

// scratch-plugin/src/summary-service.tsimport { Service } from '@deepseek-ai/cordis'import type { Context } from '@deepseek-ai/cordis'import { BlockAssembler, createUserMessage } from '@deepseek-ai/dsh-llm'import type { ContentBlock, GenerateOptions, Message } from '@deepseek-ai/dsh-llm'import { SessionId } from '@deepseek-ai/dsh-session'declare module '@deepseek-ai/cordis' {  interface Context {    summaryService: SummaryService  }}export interface SummaryOptions {  maxLength?: number  style?: 'brief' | 'detailed'  forceRefresh?: boolean}/** Hard cap on transcript characters sent to the summarizer. */const MAX_TRANSCRIPT_CHARS = 24_000/** Per-message cap so one huge tool dump cannot crowd out the rest. */const MAX_MESSAGE_CHARS = 2_000/** Join the text blocks of one message; other block kinds are not transcript text. */function messageText(blocks: readonlyContentBlock[]): string {  const parts: string[] = []  for (const block of blocks) {    if (block.type === 'text') parts.push(block.text)  }  return parts.join('\n').trim()}/** Clamp one string to a character budget. */function clamp(text: string, limit: number): string {  return text.length <= limit ? text : `${text.slice(0, limit)}…`}/** Render a derived history as a role-prefixed transcript, keeping the newest tail on overflow. */function renderTranscript(history: readonlyMessage[]): string {  const lines: string[] = []  for (const message of history) {    const text = messageText(message.content)    if (text.length === 0) continue    lines.push(`${message.role.toUpperCase()}: ${clamp(text, MAX_MESSAGE_CHARS)}`)  }  const joined = lines.join('\n\n')  if (joined.length <= MAX_TRANSCRIPT_CHARS) return joined  // Keep the tail: the latest turns describe the current state of the work.  return `…\n${joined.slice(joined.length - MAX_TRANSCRIPT_CHARS)}`}/** Turn a terminal finish reason into an auxiliary-call failure. */function finishError(finish: { kind: string; failure?: { message?: string; code?: string } }): Error | undefined {  switch (finish.kind) {    case 'stop':      return undefined    case 'error':    case 'aborted': {      const error = new Error(finish.failure?.message ?? '摘要模型调用失败')      if (finish.failure?.code !== undefined) (error as Error & { code?: string }).code = finish.failure.code      return error    }    case 'max-tokens':      return new Error('摘要输出达到 maxTokens 上限，请调大 max_length')    default:      return new Error(`摘要模型返回了不支持的结束原因 "${finish.kind}"`)  }}export class SummaryService extends Service {  static inject = ['sessions', 'llm']  private cache = new Map<string, string>()  constructor(ctx: Context) {    super(ctx, 'summaryService')  }  async summarize(sessionId: string, options: SummaryOptions = {}): Promise<string> {    const { maxLength = 200, style = 'brief', forceRefresh = false } = options    const cacheKey = `${sessionId}:${style}:${maxLength}`    if (!forceRefresh && this.cache.has(cacheKey)) {      return this.cache.get(cacheKey)!    }    // `sessions.get()` takes a branded id and may miss.    const session = this.ctx.sessions.get(SessionId(sessionId))    if (session === undefined) throw new Error(`summary: 找不到会话 ${sessionId}`)    // The session log already records the exact route its turns ran on, so the    // summarizer reuses it instead of needing provider/model configuration.    const header = session.requestHeader()    const provider = header?.config.provider    const model = header?.config.model    if (provider === undefined || model === undefined) {      throw new Error(`summary: 会话 ${sessionId} 还没有 request/header，无法确定 provider/model`)    }    const transcript = renderTranscript(session.deriveMessages())    if (transcript.length === 0) throw new Error(`summary: 会话 ${sessionId} 没有可总结的文本消息`)    const system = style === 'brief'      ? `用不超过 ${maxLength} 字的中文总结下面这段 AI 编码助手会话：概括用户的诉求、已完成的工作、得到的结论和尚未解决的问题。只输出摘要正文。`      : '详细总结下面这段 AI 编码助手会话，用中文分节写出：会话目标、按轮次的关键动作与工具调用、发现的问题与根因、当前状态、未完成事项。只输出摘要正文。'    const maxTokens = style === 'brief'      ? Math.min(4_096, Math.max(512, maxLength * 6))      : 4_096    const messages: Message[] = [createUserMessage({      content: [{ type: 'text', text: transcript }],      source: { kind: 'plugin', plugin: 'scratch-plugin/summary-service' },    })]    const request: GenerateOptions = {      provider,      model,      messages,      system,      maxTokens,      sessionId: session.id,    }    // `ctx.llm` is streaming-only: assemble it instead of expecting `complete()`.    const assembler = new BlockAssembler()    for await (const chunk of this.ctx.llm.stream(request)) assembler.push(chunk)    const finish = assembler.finish    const summary = assembler.blocks()      .filter((block): block is Extract<ContentBlock, { type: 'text' }> => block.type === 'text')      .map(block => block.text)      .join('\n')      .trim()    if (finish.kind !== 'stop' && finish.kind !== 'max-tokens') {      throw finishError(finish) ?? new Error('summary: 摘要模型调用失败')    }    if (summary.length === 0) {      throw finishError(finish) ?? new Error('summary: 摘要模型没有产出文本')    }    this.cache.set(cacheKey, summary)    return summary  }  invalidate(sessionId: string) {    for (const key of this.cache.keys()) {      if (key.startsWith(`${sessionId}:`)) this.cache.delete(key)    }  }}export async function apply(ctx: Context) {  await ctx.plugin(SummaryService)}

// scratch-plugin/src/summary-tools.tsimport { writeFile } from 'node:fs/promises'import type { Context } from '@deepseek-ai/cordis'import { defineTool } from '@deepseek-ai/dsh-tools'export const name = 'summary-tools'export const inject = ['summaryService', 'tools']export functionapply(ctx: Context) {  // 工具一：快速总结  ctx.tools.register(defineTool({    name: 'summarize_session',    description: '总结指定会话的内容',    parameters: {      session_id: { type: 'string', required: true, description: '要总结的会话 ID' },      max_length: { type: 'number', description: '摘要最大字数，默认 200' },    },    output: {      schema: { type: 'string' },      render: (_args, value) => [{ type: 'text', text: value }],    },    async execute(args) {      const summary = await ctx.summaryService.summarize(args.session_id, {        maxLength: args.max_length,      })      return summary    },  }))  // 工具二：详细归档摘要  ctx.tools.register(defineTool({    name: 'archive_session',    description: '生成会话的详细归档摘要并保存到文件',    parameters: {      session_id: { type: 'string', required: true },      output_path: { type: 'string', required: true, description: '归档文件的写入路径' },    },    output: {      schema: { type: 'string' },      render: (_args, value) => [{ type: 'text', text: value }],    },    async execute(args) {      const summary = await ctx.summaryService.summarize(args.session_id, {        style: 'detailed',        forceRefresh: true,      })      // `node:fs/promises` rather than a `ctx.fs` service: this plugin injects none.      await writeFile(args.output_path, `${summary}\n`, 'utf8')      return `归档摘要已写入 ${args.output_path}`    },  }))}

- insert:    - id: summary-service      name: '/home/sandui/deepseek-harness/scratch-plugin/src/summary-service.ts'    - id: summary-tools      name: '/home/sandui/deepseek-harness/scratch-plugin/src/summary-tools.ts'

import { Context } from '@deepseek-ai/cordis'export const name = 'event-watcher'export function apply(ctx: Context) {  // session/created钩子，在会话创建的时候执行， 只观察，不干涉  ctx.on('session/created', (session) => {    console.log('New session:', session.id)  })  // 门禁：执行前拦截  ctx.on('tools/pre-execute', async (execution, next) => {    if (execution.name === 'forbidden_tool') {      return { kind: 'deny', reason: 'This tool is forbidden by policy' }    }    return next()   // 放行给后续监听器  })  // 改写：执行后加工结果  ctx.on('tools/post-execute', async (execution, result, next) => {    const decision = await next()    // 检查 result，附加信息，或者修改 decision    return decision  })}

ctx.on('tools/pre-execute', async (execution, next) => {  // 下游（包括默认的 allow 逻辑）的结果会从这里回来  const downstream = await next()  // 你可以在放行之前"包一层"：比如记录耗时、附加审计信息  return downstream})

// guardrail.tsexport const name = 'guardrail'const DANGEROUS_PATTERNS = [/rm\s+-rf\s+\//, /mkfs\./, /dd\s+if=/]export function apply(ctx: Context) {  ctx.on('tools/pre-execute', async (execution, next) => {    // 决策型监听器：命中规则就直接短路，不调 next()    if (execution.name === 'shell_execute') {      const command: string = execution.args.command ?? ''      if (DANGEROUS_PATTERNS.some(p => p.test(command))) {        return { kind: 'deny', reason: `Blocked dangerous command: ${command}` }      }    }    // 没命中，放行给下游（包括默认的 allow 逻辑）    return next()  })}

const SECRET_PATTERNS: Array<[RegExp, string]> = [  [/sk-[A-Za-z0-9]{20,}/g, 'sk-***REDACTED***'],  [/[\w.+-]+@[\w-]+\.[\w.]+/g, '***@***.***'],  [/1[3-9]\d{9}/g, '1**********'],]function redact(text: string): string {  return SECRET_PATTERNS.reduce((acc, [re, mask]) => acc.replace(re, mask), text)}export function apply(ctx: Context) {  ctx.on('tools/post-execute', async (execution, result, next) => {    // 先让下游（默认的结果组装逻辑）跑完，拿到最终决策    const decision = await next()    // 只改"成功返回"的内容；deny 等决策原样放行    if (decision.kind === 'allow' && typeof decision.content === 'string') {      return { ...decision, content: redact(decision.content) }    }    return decision  })}