cc-viewer 1.6.342 → 1.6.343

package/dist/index.html

@@ -21,7 +21,7 @@
     // 整体显示大小已弃用 CSS zoom：Electron 改用 webFrame.setZoomFactor（首屏抢占见
     // electron/tab-content-preload.js），纯浏览器交由用户用浏览器自带快捷键缩放，故此处不再设 zoom。
   </script>
-  <script type="module" crossorigin src="./assets/index-CtSbjm-X.js"></script>
+  <script type="module" crossorigin src="./assets/index-5v2dgTRS.js"></script>
   <link rel="modulepreload" crossorigin href="./assets/vendor-antd-D5HmSDSg.js">
   <link rel="modulepreload" crossorigin href="./assets/vendor-codemirror-C5yuj7ze.js">
   <link rel="modulepreload" crossorigin href="./assets/vendor-mdxeditor-BcEooTvb.js">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-viewer",
-  "version": "1.6.342",
+  "version": "1.6.343",
   "description": "Claude Code logging, visualization, and management toolkit — launch a web viewer alongside Claude Code with full request/response tracing, proxy, and mobile support",
   "license": "MIT",
   "main": "server.js",

package/server/lib/create_system_prompt.js

@@ -0,0 +1,504 @@
+// System-prompt template builder: resolves runtime variables, loads
+// systemPromptModel.md + the presets, and renders/assembles system-prompt text.
+// Consumed by server/lib/system-prompt-presets.js and runnable directly as a CLI.
+//
+// CLI usage (renders with missing variables blanked out):
+//   node server/lib/create_system_prompt.js                 # base model template
+//   node server/lib/create_system_prompt.js deepseek-v4-pro # a named preset
+//   node server/lib/create_system_prompt.js --list          # list presets
+
+import { execFileSync } from 'node:child_process'
+import { readFileSync, statSync } from 'node:fs'
+import os from 'node:os'
+import { delimiter, join, sep } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+const TEMPLATE_VARIABLE_PATTERN = /\$\{([^}]+)\}/g
+
+export const DYNAMIC_BOUNDARY = '__SYSTEM_PROMPT_DYNAMIC_BOUNDARY__'
+
+const MODEL_TEMPLATE_URL = new URL('../system-prompt-templates/systemPromptModel.md', import.meta.url)
+const PRESETS_DIR_URL = new URL('../system-prompt-templates/presets/', import.meta.url)
+const PRESETS_INDEX_URL = new URL('index.json', PRESETS_DIR_URL)
+const PRESET_ID_PATTERN = /^[A-Za-z0-9._-]+$/
+
+function stringifyTemplateValue(value) {
+  if (typeof value === 'string') return value
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? String(value) : ''
+  }
+  return ''
+}
+
+function stringOrEmpty(readValue) {
+  try {
+    const value = readValue()
+    if (value === null || value === undefined) return ''
+    return String(value)
+  } catch {
+    return ''
+  }
+}
+
+function numberOrEmpty(readValue) {
+  try {
+    const value = Number(readValue())
+    return Number.isFinite(value) ? value : ''
+  } catch {
+    return ''
+  }
+}
+
+function envString(name) {
+  return stringOrEmpty(() => process.env[name] ?? '')
+}
+
+function commandOutput(command, args, cwd) {
+  return stringOrEmpty(() =>
+    execFileSync(command, args, {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim(),
+  )
+}
+
+function firstNonEmpty(...values) {
+  return values.find(value => value.length > 0) ?? ''
+}
+
+function currentDate(timeZone, date) {
+  if (timeZone.length > 0) {
+    const formatted = stringOrEmpty(() =>
+      new Intl.DateTimeFormat('en-CA', {
+        timeZone,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+      }).format(date),
+    )
+    if (formatted.length > 0) return formatted
+  }
+  return stringOrEmpty(() => date.toISOString().slice(0, 10))
+}
+
+function mergeSystemPromptVariables(base, overrides) {
+  return {
+    environment: { ...base.environment, ...overrides.environment },
+    git: { ...base.git, ...overrides.git },
+    os: { ...base.os, ...overrides.os },
+    runtime: { ...base.runtime, ...overrides.runtime },
+    time: { ...base.time, ...overrides.time },
+    permissions: { ...base.permissions, ...overrides.permissions },
+    sandbox: { ...base.sandbox, ...overrides.sandbox },
+    terminal: { ...base.terminal, ...overrides.terminal },
+    filesystem: { ...base.filesystem, ...overrides.filesystem },
+    model: { ...base.model, ...overrides.model },
+    memory: { ...base.memory, ...overrides.memory },
+    scratchpad: { ...base.scratchpad, ...overrides.scratchpad },
+  }
+}
+
+function slugifyPath(value) {
+  return value.replace(/[^A-Za-z0-9]/g, '-')
+}
+
+function directoryExists(dir) {
+  if (dir.length === 0) return false
+  try {
+    return statSync(dir).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+function resolveMemory(home, cwd) {
+  const overrideDir = firstNonEmpty(
+    envString('CC_MEMORY_DIR'),
+    envString('CLAUDE_MEMORY_DIR'),
+  )
+  const dir =
+    overrideDir.length > 0
+      ? overrideDir
+      : home.length > 0
+        ? join(home, '.claude', 'projects', slugifyPath(cwd), 'memory') + sep
+        : ''
+  const enabled = directoryExists(dir)
+  const index = enabled
+    ? stringOrEmpty(() => readFileSync(join(dir, 'MEMORY.md'), 'utf8'))
+    : ''
+  return { dir, index, enabled: enabled ? 'true' : 'false' }
+}
+
+export function createSystemPromptVariables(overrides = {}) {
+  const cwd = stringOrEmpty(() => process.cwd())
+  const now = new Date()
+  const timeZone = stringOrEmpty(
+    () => Intl.DateTimeFormat().resolvedOptions().timeZone,
+  )
+  const isGitRepository =
+    commandOutput('git', ['rev-parse', '--is-inside-work-tree'], cwd) === 'true'
+  const gitRoot = isGitRepository
+    ? commandOutput('git', ['rev-parse', '--show-toplevel'], cwd)
+    : ''
+  const gitBranch = isGitRepository
+    ? firstNonEmpty(
+        commandOutput('git', ['branch', '--show-current'], cwd),
+        commandOutput('git', ['rev-parse', '--short', 'HEAD'], cwd),
+      )
+    : ''
+  const gitMainBranch = isGitRepository
+    ? firstNonEmpty(
+        commandOutput('git', ['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], cwd).replace(/^origin\//, ''),
+        commandOutput('git', ['config', '--get', 'init.defaultBranch'], cwd),
+      )
+    : ''
+
+  const variables = {
+    environment: {
+      cwd,
+      originalCwd: envString('PWD'),
+      home: envString('HOME'),
+      user: firstNonEmpty(envString('USER'), envString('USERNAME')),
+      workspaceRoots: firstNonEmpty(
+        envString('CODEX_WORKSPACE_ROOTS'),
+        envString('CLAUDE_WORKSPACE_ROOTS'),
+      ),
+      path: envString('PATH'),
+      lang: firstNonEmpty(envString('LANG'), envString('LC_ALL')),
+    },
+    git: {
+      isRepository: isGitRepository ? 'true' : 'false',
+      root: gitRoot,
+      branch: gitBranch,
+      mainBranch: gitMainBranch,
+      userName: isGitRepository
+        ? commandOutput('git', ['config', 'user.name'], cwd)
+        : '',
+      status: isGitRepository
+        ? commandOutput('git', ['status', '--short'], cwd)
+        : '',
+      recentCommits: isGitRepository
+        ? commandOutput('git', ['log', '--oneline', '-5'], cwd)
+        : '',
+    },
+    os: {
+      platform: stringOrEmpty(() => process.platform),
+      type: stringOrEmpty(() => os.type()),
+      arch: stringOrEmpty(() => os.arch()),
+      shell: envString('SHELL'),
+      version: stringOrEmpty(() => os.version()),
+      release: stringOrEmpty(() => os.release()),
+      hostname: stringOrEmpty(() => os.hostname()),
+      availableParallelism: numberOrEmpty(() => os.availableParallelism()),
+      totalMemory: numberOrEmpty(() => os.totalmem()),
+      freeMemory: numberOrEmpty(() => os.freemem()),
+      uptime: numberOrEmpty(() => os.uptime()),
+    },
+    runtime: {
+      nodeVersion: stringOrEmpty(() => process.version),
+      execPath: stringOrEmpty(() => process.execPath),
+      pid: numberOrEmpty(() => process.pid),
+      ppid: numberOrEmpty(() => process.ppid),
+    },
+    time: {
+      current: stringOrEmpty(() => now.toString()),
+      iso: stringOrEmpty(() => now.toISOString()),
+      date: currentDate(timeZone, now),
+      timezone: timeZone,
+    },
+    permissions: {
+      mode: firstNonEmpty(
+        envString('CLAUDE_PERMISSION_MODE'),
+        envString('CODEX_PERMISSION_MODE'),
+      ),
+      approvalsReviewer: envString('CODEX_APPROVALS_REVIEWER'),
+    },
+    sandbox: {
+      mode: firstNonEmpty(envString('SANDBOX_MODE'), envString('CODEX_SANDBOX_MODE')),
+      networkAccess: firstNonEmpty(
+        envString('NETWORK_ACCESS'),
+        envString('CODEX_NETWORK_ACCESS'),
+      ),
+      writableRoots: firstNonEmpty(
+        envString('WRITABLE_ROOTS'),
+        envString('CODEX_WRITABLE_ROOTS'),
+      ),
+    },
+    terminal: {
+      term: envString('TERM'),
+      colorTerm: envString('COLORTERM'),
+      columns: numberOrEmpty(() => process.stdout.columns),
+      rows: numberOrEmpty(() => process.stdout.rows),
+    },
+    filesystem: {
+      tmpdir: stringOrEmpty(() => os.tmpdir()),
+      pathSeparator: sep,
+      pathDelimiter: delimiter,
+    },
+    model: {
+      name: firstNonEmpty(envString('CLAUDE_MODEL'), envString('ANTHROPIC_MODEL')),
+      knowledgeCutoff: envString('CLAUDE_KNOWLEDGE_CUTOFF'),
+    },
+    memory: resolveMemory(envString('HOME'), cwd),
+    scratchpad: {
+      dir: firstNonEmpty(
+        envString('CC_SCRATCHPAD_DIR'),
+        envString('CLAUDE_SCRATCHPAD_DIR'),
+      ),
+    },
+  }
+
+  return mergeSystemPromptVariables(variables, overrides)
+}
+
+function readDottedPath(path, variables) {
+  const normalizedPath = path.trim()
+  if (Object.prototype.hasOwnProperty.call(variables, normalizedPath)) {
+    return variables[normalizedPath]
+  }
+
+  return normalizedPath.split('.').reduce((current, key) => {
+    if (
+      current === null ||
+      current === undefined ||
+      typeof current !== 'object' ||
+      !Object.prototype.hasOwnProperty.call(current, key)
+    ) {
+      return undefined
+    }
+    return current[key]
+  }, variables)
+}
+
+function replaceTemplateVariable(rawMatch, rawName, variables, missingVariableMode) {
+  const value = readDottedPath(rawName, variables)
+  if (value !== undefined) {
+    return stringifyTemplateValue(value)
+  }
+
+  if (missingVariableMode === 'keep') return rawMatch
+  if (missingVariableMode === 'throw') {
+    throw new Error(`Missing system prompt template variable: ${rawName.trim()}`)
+  }
+  return ''
+}
+
+export function listTemplateVariables(markdownTemplate) {
+  const names = new Set()
+  for (const match of markdownTemplate.matchAll(TEMPLATE_VARIABLE_PATTERN)) {
+    names.add(match[1].trim())
+  }
+  return Array.from(names).sort()
+}
+
+export function createSystemPrompt(markdownTemplate, options) {
+  const variables = options.variables
+  const missingVariableMode = options.missingVariableMode ?? 'throw'
+
+  return markdownTemplate.replace(TEMPLATE_VARIABLE_PATTERN, (match, name) =>
+    replaceTemplateVariable(match, name, variables, missingVariableMode),
+  )
+}
+
+function isTrue(value) {
+  return value === 'true'
+}
+
+// Ordered header -> key mapping. Section prose lives only in
+// systemPromptModel.md (parsed at runtime), never duplicated here.
+export const SYSTEM_PROMPT_SECTIONS = [
+  { key: 'preamble', header: null },
+  { key: 'environment', header: '# Environment' },
+  { key: 'operatingSystem', header: '# Operating system' },
+  { key: 'runtime', header: '# Runtime' },
+  { key: 'time', header: '# Time' },
+  { key: 'permissionsSandbox', header: '# Permissions and sandbox' },
+  { key: 'terminal', header: '# Terminal' },
+  { key: 'filesystem', header: '# Filesystem' },
+  { key: 'model', header: '# Model' },
+  { key: 'git', header: '# Git' },
+  {
+    key: 'memory',
+    header: '# Memory',
+    includeWhen: variables => isTrue(variables.memory.enabled),
+  },
+  {
+    key: 'scratchpad',
+    header: '# Scratchpad Directory',
+    includeWhen: variables => variables.scratchpad.dir.length > 0,
+  },
+  { key: 'contextManagement', header: '# Context management' },
+]
+
+// Splits a model template into its preamble and a header -> raw-section-text map.
+// Level-1 headers (`# `) inside fenced code blocks are ignored so fenced
+// examples (e.g. the memory frontmatter) do not start new sections.
+function splitTemplate(markdownTemplate) {
+  const parts = markdownTemplate.split(DYNAMIC_BOUNDARY)
+  if (parts.length !== 2) {
+    throw new Error(
+      `System prompt template must contain exactly one ${DYNAMIC_BOUNDARY} marker (found ${parts.length - 1})`,
+    )
+  }
+  const preamble = parts[0].trim()
+  const sectionsByHeader = new Map()
+  const lines = parts[1].split('\n')
+  let currentHeader = null
+  let buffer = []
+  let inFence = false
+
+  const flush = () => {
+    if (currentHeader !== null) {
+      sectionsByHeader.set(currentHeader, buffer.join('\n').trim())
+    }
+  }
+
+  for (const line of lines) {
+    if (line.trimStart().startsWith('```')) {
+      inFence = !inFence
+    }
+    if (!inFence && line.startsWith('# ')) {
+      flush()
+      currentHeader = line.trim()
+      buffer = [line]
+      continue
+    }
+    if (currentHeader !== null) buffer.push(line)
+  }
+  flush()
+  return { preamble, sectionsByHeader }
+}
+
+export function assembleSystemPrompt(markdownTemplate, options) {
+  const { variables, missingVariableMode, sections } = options
+  const known = new Set(SYSTEM_PROMPT_SECTIONS.map(section => section.key))
+  if (sections) {
+    for (const key of sections) {
+      if (!known.has(key)) {
+        throw new Error(`Unknown system prompt section key: ${key}`)
+      }
+    }
+  }
+  const selected = sections ? new Set(sections) : known
+  const { preamble, sectionsByHeader } = splitTemplate(markdownTemplate)
+
+  const rendered = []
+  for (const section of SYSTEM_PROMPT_SECTIONS) {
+    if (!selected.has(section.key)) continue
+    if (section.includeWhen && !section.includeWhen(variables)) continue
+
+    let raw
+    if (section.header === null) {
+      raw = preamble
+    } else {
+      const found = sectionsByHeader.get(section.header)
+      // A template may legitimately include only a subset of sections (e.g. the
+      // presets omit git and most environment blocks); skip any that are absent.
+      if (found === undefined) continue
+      raw = found
+    }
+    rendered.push(createSystemPrompt(raw, { variables, missingVariableMode }))
+  }
+
+  // The MEMORY.md contents are runtime data, not authored prose, and they are
+  // already self-titled ("# Memory index"). Append them verbatim as a trailing
+  // block whenever the memory section is present, without re-templating (the
+  // index may legitimately contain literal ${...} text).
+  if (
+    selected.has('memory') &&
+    isTrue(variables.memory.enabled) &&
+    variables.memory.index.trim().length > 0
+  ) {
+    rendered.push(variables.memory.index)
+  }
+
+  return rendered.map(part => part.trim()).filter(Boolean).join('\n\n')
+}
+
+export function loadModelTemplate() {
+  return readFileSync(MODEL_TEMPLATE_URL, 'utf8')
+}
+
+// The human-readable reference for the ${...} template variables (rendered in the
+// "Edit System Prompt" modal's parameter-docs popup).
+export function loadVariablesDoc() {
+  return readFileSync(new URL('../system-prompt-templates/systemPromptVariables.md', import.meta.url), 'utf8')
+}
+
+function assertSafePresetId(id) {
+  if (typeof id !== 'string' || !PRESET_ID_PATTERN.test(id) || id.includes('..')) {
+    throw new Error(`Invalid preset id: ${JSON.stringify(id)}`)
+  }
+  return id
+}
+
+export function loadPreset(id) {
+  // Accept an optional `.md` suffix so `... deepseek-v4-pro.md` resolves too.
+  const normalized = typeof id === 'string' ? id.replace(/\.md$/i, '') : id
+  const safeId = assertSafePresetId(normalized)
+  return readFileSync(new URL(`${safeId}.md`, PRESETS_DIR_URL), 'utf8')
+}
+
+export function listPresets() {
+  const manifest = JSON.parse(readFileSync(PRESETS_INDEX_URL, 'utf8'))
+  return manifest
+}
+
+// Strips HTML editor comments (`<!-- ... -->`) that document the preset file but
+// must not leak into the rendered prompt.
+function stripEditorComments(source) {
+  return source.replace(/<!--[\s\S]*?-->/g, '').replace(/^\s+/, '')
+}
+
+// Normalizes a preset into a full template. Two shapes are supported:
+//   - Self-contained (what the shipped presets use): the preset already has its
+//     own DYNAMIC_BOUNDARY + dynamic sections, so it is returned as-is.
+//   - Preamble-only (no boundary): composed with systemPromptModel.md's shared
+//     dynamic tail, so environment snippets can stay unified. None of the shipped
+//     presets currently use this path.
+function toFullTemplate(presetSource) {
+  const source = stripEditorComments(presetSource)
+  if (source.includes(DYNAMIC_BOUNDARY)) return source
+  const modelParts = loadModelTemplate().split(DYNAMIC_BOUNDARY)
+  return `${source.trim()}\n\n${DYNAMIC_BOUNDARY}\n${modelParts[1]}`
+}
+
+export function renderModel(options) {
+  return assembleSystemPrompt(loadModelTemplate(), options)
+}
+
+export function renderPreset(id, options) {
+  return assembleSystemPrompt(toFullTemplate(loadPreset(id)), options)
+}
+
+// Returns a preset composed into a full template with the dynamic-boundary marker
+// removed and `${...}` placeholders left LITERAL (no variable substitution). This
+// is the raw text used to pre-fill the "Edit System Prompt" editor, where the user
+// tweaks it before saving.
+export function renderPresetTemplate(id) {
+  return toFullTemplate(loadPreset(id))
+    .split(DYNAMIC_BOUNDARY)
+    .map(part => part.trim())
+    .filter(Boolean)
+    .join('\n\n')
+}
+
+function runCli() {
+  const arg = process.argv[2]
+  if (arg === '--list' || arg === '-l') {
+    process.stdout.write(JSON.stringify(listPresets(), null, 2) + '\n')
+    return
+  }
+  const variables = createSystemPromptVariables()
+  const output = arg
+    ? renderPreset(arg, { variables, missingVariableMode: 'empty' })
+    : renderModel({ variables, missingVariableMode: 'empty' })
+  process.stdout.write(output + '\n')
+}
+
+// Guard against `process.argv[1]` being undefined (e.g. under `node --test`,
+// where importing this module must not run the CLI).
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  runCli()
+}

package/server/lib/system-prompt-presets.js

@@ -0,0 +1,67 @@
+// Serves the built-in system-prompt presets (server/system-prompt-templates/presets/*)
+// to the "Edit System Prompt" modal. Reads the manifest and renders each preset into
+// raw editor text (placeholders left literal) via the system-prompt builder.
+//
+// This path is pure file reads + string ops — it does NOT call
+// createSystemPromptVariables, so no git subprocess is spawned when serving.
+import { listPresets, renderPresetTemplate, loadVariablesDoc } from './create_system_prompt.js';
+
+// Returns a flat list of presets with their raw editor text:
+//   [{ id, title, description, match, category, defaultMode, text }]
+// Best-effort per entry: a preset that fails to load/render is logged and
+// skipped rather than failing the whole list.
+export function listSystemPromptPresets() {
+  let manifest;
+  try {
+    manifest = listPresets();
+  } catch (e) {
+    console.warn('[CC Viewer] system-prompt presets manifest unreadable:', e.message);
+    return [];
+  }
+  const categories = (manifest && manifest.categories) || {};
+  const out = [];
+  for (const [category, entries] of Object.entries(categories)) {
+    if (!Array.isArray(entries)) continue;
+    for (const entry of entries) {
+      if (!entry || typeof entry.id !== 'string') continue;
+      let text;
+      try {
+        text = renderPresetTemplate(entry.id);
+      } catch (e) {
+        console.warn(`[CC Viewer] system-prompt preset "${entry.id}" render failed:`, e.message);
+        continue;
+      }
+      out.push({
+        id: entry.id,
+        title: entry.title || entry.id,
+        description: entry.description || '',
+        match: entry.match || '',
+        category,
+        defaultMode: entry.defaultMode === 'override' ? 'override' : 'append',
+        text,
+      });
+    }
+  }
+  return out;
+}
+
+// Returns the ${...} template-variable reference (systemPromptVariables.md) as
+// markdown, or '' if it can't be read (best-effort; the modal hides its help
+// affordance when empty).
+export function getSystemPromptVariablesDoc() {
+  try {
+    return loadVariablesDoc();
+  } catch (e) {
+    console.warn('[CC Viewer] system-prompt variables doc unreadable:', e.message);
+    return '';
+  }
+}
+
+// Groups a flat preset list by category, preserving first-seen order.
+export function groupPresetsByCategory(presets) {
+  const categories = {};
+  for (const p of presets) {
+    (categories[p.category] || (categories[p.category] = [])).push(p);
+  }
+  return categories;
+}

package/server/routes/expert.js

@@ -12,6 +12,7 @@ import {
   MODEL_PROMPT_DIR, normalizeModelName, listModelPrompts,
   writeModelPrompt, deleteModelPrompt,
 } from '../lib/model-system-prompts.js';
+import { listSystemPromptPresets, groupPresetsByCategory, getSystemPromptVariablesDoc } from '../lib/system-prompt-presets.js';
 import { LOG_DIR } from '../../findcc.js';
 
 // 当前工作区目录全部由服务端解析（绝不接收客户端路径 → 无遍历面）：
@@ -148,9 +149,26 @@ function postModelPrompts(req, res, parsedUrl, isLocal, deps) {
   });
 }
 
+// 内置系统提示词预设（server/system-prompt-templates/presets/*）：只读，返回可直接回填编辑器的原始模板文本
+// （占位符保持字面量，不做变量替换），供「+ 添加模型」时按名称匹配/下拉选择预填。
+function getSystemPromptPresets(req, res, parsedUrl, isLocal, deps) {
+  try {
+    const presets = listSystemPromptPresets();
+    sendJson(res, 200, {
+      presets,
+      categories: groupPresetsByCategory(presets),
+      variablesDoc: getSystemPromptVariablesDoc(),
+    });
+  } catch (e) {
+    console.error('[CC Viewer] expert system-prompt-presets GET failed:', e.message);
+    sendJson(res, 500, { error: 'read_failed' });
+  }
+}
+
 export const expertRoutes = [
   { method: 'GET', match: 'exact', path: '/api/expert/system-text', handler: getSystemText },
   { method: 'POST', match: 'exact', path: '/api/expert/system-text', handler: postSystemText },
   { method: 'GET', match: 'exact', path: '/api/expert/model-prompts', handler: getModelPrompts },
   { method: 'POST', match: 'exact', path: '/api/expert/model-prompts', handler: postModelPrompts },
+  { method: 'GET', match: 'exact', path: '/api/expert/system-prompt-presets', handler: getSystemPromptPresets },
 ];

package/server/system-prompt-templates/presets/GLM-5.2.md

@@ -0,0 +1,63 @@
+<!--
+Preset: GLM-5.2  (category: Global)
+Self-contained template: a tuned preamble plus its own dynamic sections
+(a boundary marker, an OS-only # Environment, and a verbatim # Memory; no Git).
+Edit this file directly.
+-->
+
+You are ${model.name}, an interactive agent that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+
+IMPORTANT: Assist with defensive software engineering work. Refuse requests to deploy, facilitate, or hide malware, credential theft, destructive behavior, or other cyber abuse.
+IMPORTANT: Never generate or guess URLs unless you are confident they help the user with programming. Prefer URLs the user provides or ones found in local files.
+
+# Doing tasks
+ - Treat unclear instructions in the context of software engineering and the current working directory.
+ - Read the relevant code before proposing or making changes, and follow the conventions already present in the file.
+ - Keep changes scoped to the request: no unrequested features, refactors, fallbacks, or one-off abstractions.
+ - When an approach fails, diagnose the error before trying something else; don't repeat the same failing action.
+ - Avoid security vulnerabilities (injection, XSS, path traversal, and the OWASP top 10); fix any insecure code you write.
+ - Validate changes by running the relevant tests or code path before reporting completion.
+
+# Using tools
+ - Prefer the dedicated tool for reading files, editing files, searching contents, and running commands over ad-hoc shell commands.
+ - Issue independent tool calls in parallel when they have no dependencies.
+ - Track multi-step work and mark each step complete as you go.
+
+# Executing actions with care
+Weigh reversibility and blast radius. Local, reversible actions like editing files or running tests are fine. Confirm with the user before hard-to-reverse or shared-system actions: deleting files or branches, force-pushing, resetting, sending messages, or posting to external services. Investigate unexpected state before overwriting it.
+
+# Tone and style
+ - Keep output brief and direct; lead with the answer or action. No filler, and no emojis unless the user asks.
+ - Reference code with the `file_path:line_number` pattern.
+ - Respond in the user's language, using the `${environment.lang}` locale when the language is not otherwise clear.
+
+__SYSTEM_PROMPT_DYNAMIC_BOUNDARY__
+
+# Environment
+ - Platform: ${os.platform}
+ - OS Version: ${os.version}
+ - Architecture: ${os.arch}
+ - Shell: ${os.shell}
+
+# Memory
+
+You have a persistent file-based memory at `${memory.dir}`. This directory already exists — write to it directly with the Write tool (do not run mkdir or check for its existence). Each memory is one file holding one fact, with frontmatter:
+
+```markdown
+---
+name: <short-kebab-case-slug>
+description: <one-line summary — used to decide relevance during recall>
+metadata:
+  type: user | feedback | project | reference
+---
+
+<the fact; for feedback/project, follow with **Why:** and **How to apply:** lines. Link related memories with [[their-name]].>
+```
+
+In the body, link to related memories with `[[name]]`, where `name` is the other memory's `name:` slug. Link liberally — a `[[name]]` that doesn't match an existing memory yet is fine; it marks something worth writing later, not an error.
+
+`user` — who the user is (role, expertise, preferences). `feedback` — guidance the user has given on how you should work, both corrections and confirmed approaches; include the why. `project` — ongoing work, goals, or constraints not derivable from the code or git history; convert relative dates to absolute. `reference` — pointers to external resources (URLs, dashboards, tickets).
+
+After writing the file, add a one-line pointer in `MEMORY.md` (`- [Title](file.md) — hook`). `MEMORY.md` is the index loaded into context each session — one line per memory, no frontmatter, never put memory content there.
+
+Before saving, check for an existing file that already covers it — update that file rather than creating a duplicate; delete memories that turn out to be wrong. Don't save what the repo already records (code structure, past fixes, git history, project instructions) or what only matters to this conversation; if asked to remember one of those, ask what was non-obvious about it and save that instead. Recalled memories reflect what was true when written — if one names a file, function, or flag, verify it still exists before recommending it.