sprag-cli 3.40.0

package/examples/statusline-command.ps1

@@ -0,0 +1,43 @@
+# Claude Code statusline (Windows PowerShell version)
+# Mirrors the POSIX sh script — prints "user@host:cwd" then appends
+# claude-token-saver output as a second segment.
+#
+# Install:
+#   1) npm install -g claude-token-saver
+#   2) Save this file as: %USERPROFILE%\.claude\statusline-command.ps1
+#   3) In %USERPROFILE%\.claude\settings.json add:
+#      {
+#        "statusLine": {
+#          "type": "command",
+#          "command": "powershell.exe -NoProfile -ExecutionPolicy Bypass -File %USERPROFILE%\\.claude\\statusline-command.ps1",
+#          "refreshInterval": 1
+#        }
+#      }
+#
+# Requires Windows Terminal or PowerShell 7+ for ANSI color + emoji rendering.
+# (Classic conhost cmd renders colors but may garble emoji.)
+
+$stdin = [Console]::In.ReadToEnd()
+
+# Extract cwd from the JSON payload without requiring jq.
+$cwdMatch = [regex]::Match($stdin, '"cwd"\s*:\s*"([^"]*)"')
+$cwd = if ($cwdMatch.Success) { $cwdMatch.Groups[1].Value } else { (Get-Location).Path }
+
+# 1) user@host:cwd  (ANSI: green user@host, blue cwd)
+$esc = [char]27
+Write-Host -NoNewline "$esc[01;32m$env:USERNAME@$env:COMPUTERNAME$esc[00m`:$esc[01;34m$cwd$esc[00m"
+
+# 2) cache monitor (appended). Separator " | ". Falls back silently.
+Write-Host -NoNewline " $esc[90m|$esc[00m "
+
+$cacheMonitor = Get-Command claude-token-saver -ErrorAction SilentlyContinue
+if ($cacheMonitor) {
+  try {
+    & claude-token-saver --statusline --icon 2>$null
+  } catch { }
+} else {
+  # fallback: npx (first run downloads the package; subsequent runs are warm)
+  try {
+    & npx --yes claude-token-saver@latest --statusline --icon 2>$null
+  } catch { }
+}

package/examples/statusline-command.sh

@@ -0,0 +1,36 @@
+#!/bin/sh
+# Claude Code statusline (POSIX sh — works on macOS, Linux, and WSL)
+# Prints "user@host:cwd" then appends claude-token-saver as a second segment.
+#
+# Install:
+#   1) npm install -g claude-token-saver
+#   2) Save this file as: ~/.claude/statusline-command.sh
+#      chmod +x ~/.claude/statusline-command.sh  (optional)
+#   3) In ~/.claude/settings.json:
+#      {
+#        "statusLine": {
+#          "type": "command",
+#          "command": "bash ~/.claude/statusline-command.sh",
+#          "refreshInterval": 1
+#        }
+#      }
+#
+# refreshInterval keeps the TTL countdown ticking while you're idle.
+# Drop to 2 or 5 if you want lower local CPU.
+
+input=$(cat)
+
+# Extract cwd without jq dependency (jq may not be installed system-wide).
+cwd=$(echo "$input" | sed -n 's/.*"cwd"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p')
+cwd=${cwd:-$(pwd)}
+
+# 1) user@host:cwd
+printf '\033[01;32m%s@%s\033[00m:\033[01;34m%s\033[00m' "$(whoami)" "$(hostname -s)" "$cwd"
+
+# 2) cache monitor (appended). Separator " | ". Falls back silently.
+printf ' \033[90m|\033[00m '
+if command -v claude-token-saver >/dev/null 2>&1; then
+  claude-token-saver --statusline --icon 2>/dev/null || true
+else
+  npx --yes claude-token-saver@latest --statusline --icon 2>/dev/null || true
+fi

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "sprag-cli",
+  "version": "3.40.0",
+  "description": "Sprag - a quality ratchet harness for AI coding agents: model-fitting delegation, ratchet rules, doc2md, Korean style gate. Same tool as claude-token-saver, under its new name.",
+  "type": "module",
+  "bin": {
+    "sprag": "bin/cli.js",
+    "claude-token-saver": "bin/cli.js"
+  },
+  "scripts": {
+    "test": "node --test",
+    "docs:statusline": "node scripts/docs-statusline.mjs",
+    "postinstall": "node bin/cli.js install || true"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "presets/",
+    "examples/",
+    "README.md",
+    "README.ko.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "sprag",
+    "ratchet",
+    "harness",
+    "ai-agent",
+    "claude",
+    "claude-code",
+    "anthropic",
+    "model-routing",
+    "llm-router",
+    "delegation",
+    "subagent",
+    "haiku",
+    "cost-savings",
+    "token-usage",
+    "prompt-caching",
+    "cache",
+    "statusline",
+    "cli",
+    "1m-context",
+    "claude-code-statusline",
+    "claude-code-cost",
+    "model-fitting",
+    "agent-harness"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rootstudioyaml/sprag.git"
+  },
+  "homepage": "https://sprag.io",
+  "bugs": {
+    "url": "https://github.com/rootstudioyaml/sprag/issues"
+  },
+  "author": "DeepPulse (https://www.youtube.com/@DeepPulseKR)"
+}

package/presets/cohesion/cohesion-en.md

@@ -0,0 +1,26 @@
+<!--
+  English cohesion guidance — claude-token-saver's own text, distilled from the
+  same sources as the Korean supplement's cohesion section: the given-new
+  contract from text linguistics, and three studies on Korean learner writing
+  whose validated principles are language-neutral (surface connectives
+  correlate negatively or not at all with judged text quality; elaboration is
+  the only connection type with a positive correlation).
+
+  Injected at session start when `claude-token-saver cohesion on` is set and
+  the Korean guidance is off (the Korean supplement already carries these
+  rules, so injecting both would bill the same principles twice).
+-->
+
+Follow these rules whenever you write English prose the user will read — answers, documents, reports, comments, UI copy. They govern how sentences connect, which is where generated text most often reads as stilted even when every sentence is individually fine.
+
+1. **Move from known to new.** Start each sentence with information the reader already has; put the new information at the end. Let the next sentence pick up that new information and unpack it. When a transition feels rough, fix this ordering first — do not reach for a connective. Research on text quality found that surface connectives (however, moreover, additionally) correlate negatively or not at all with judged quality; elaboration — the next sentence developing what the previous one introduced — is the only connection type that correlates positively.
+
+2. **One clear referent per pronoun.** If "it", "this", or "they" could point at more than one thing in the previous sentence, repeat the noun instead. Introduce people and organizations with a role tag on first mention ("the maintainer, Alice Park") rather than dropping a bare name.
+
+3. **Keep one subject per paragraph.** Changing the grammatical subject every sentence forces the reader to reorient each time. Stay with one subject unless the topic actually shifts.
+
+4. **No leaps.** If a sentence presupposes a condition or a cause the text has not established, add the bridging sentence rather than trusting the reader to reconstruct it. The most common failure is a new entity appearing with a definite article ("the report", "the agent") before anything has introduced it.
+
+5. **Merge choppy repetition.** Three short sentences circling the same subject read worse than one sentence with the minor facts folded into modifiers. Demote the less important sentence to a clause; keep the core claim as the main clause.
+
+Do not overcorrect: settled domain terms, formal register, and verbatim quotations stay as they are.

package/presets/doc2md/convert.py

@@ -0,0 +1,363 @@
+#!/usr/bin/env python3
+"""Convert one office/PDF document to Markdown and print a JSON result.
+
+Invoked as a child process by src/doc2md.cjs. Everything it needs to say
+travels in the JSON on stdout, so the Node side never has to interpret a
+traceback:
+
+    {"ok": true,  "markdown": "...", "note": null, "truncated": false,
+     "rows": 0, "pages": 0, "markup_bytes": 0}
+    {"ok": false, "reason": "no-text", "detail": "..."}
+
+Exit status is 0 whenever the JSON was written, including for a refusal. A
+non-zero exit means the interpreter itself failed and the caller falls back to
+letting the original file be read as it always was.
+
+Two things here are defenses rather than features:
+
+* Zip bombs. pptx/xlsx/docx are zip containers, and a hostile attachment can
+  declare a small size and expand to fill the disk. The central directory is
+  checked first because it is cheap, and then every member is decompressed in
+  chunks against a hard ceiling, because the central directory is written by
+  whoever built the file and can simply lie.
+* Row count. Conversion time tracks spreadsheet rows, not bytes: a 6MB PDF
+  converts in about a second while a 6MB 200,000-row workbook takes about a
+  minute. Past the row cap the sheet is converted head-first by hand and the
+  truncation is stated in the result, because a silently shortened table is
+  worse than no table.
+"""
+
+import json
+import os
+import sys
+import zipfile
+
+MAX_UNCOMPRESSED = 500 * 1024 * 1024
+MAX_RATIO = 200
+ROW_CAP = int(os.environ.get("CTS_DOC2MD_ROW_CAP", "50000"))
+ZIP_EXTS = {".pptx", ".xlsx", ".docx"}
+
+
+def fail(reason, detail=""):
+    json.dump({"ok": False, "reason": reason, "detail": str(detail)[:500]}, sys.stdout)
+    sys.exit(0)
+
+
+# A password-protected OOXML file is not a zip at all: Office wraps the whole
+# package in an OLE compound file whose streams hold the ciphertext. Opening it
+# as a zip therefore reports "not a zip file", which reads as a broken download
+# and sends the user looking for the wrong problem.
+OLE_MAGIC = b"\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1"
+
+
+def encryption_problem(path, ext):
+    """('encrypted', detail) when the file is password-protected, else None."""
+    try:
+        with open(path, "rb") as fh:
+            head = fh.read(8)
+    except OSError:
+        return None
+
+    # Legacy .xls is an OLE file by design, so the magic alone proves nothing
+    # there. For the modern formats it can only mean encryption.
+    if ext in ZIP_EXTS and head == OLE_MAGIC:
+        return ("encrypted", "password-protected Office file (OLE-wrapped)")
+
+    # Some producers keep the zip container and put the ciphertext inside it.
+    if ext in ZIP_EXTS:
+        try:
+            import zipfile
+            with zipfile.ZipFile(path) as z:
+                names = z.namelist()
+            if any(n.startswith("EncryptedPackage") for n in names):
+                return ("encrypted", "password-protected Office file")
+        except Exception:
+            return None
+
+    if ext == ".pdf":
+        try:
+            from pdfminer.pdfparser import PDFParser
+            from pdfminer.pdfdocument import PDFDocument
+            with open(path, "rb") as fh:
+                doc = PDFDocument(PDFParser(fh))
+            # An empty owner password is the ordinary "printing restricted"
+            # case, which extracts fine. Only a document that refuses to open
+            # counts as encrypted here.
+            if doc.encryption is not None and not doc.is_extractable:
+                return ("encrypted", "password-protected PDF")
+        except Exception as e:
+            if "password" in str(type(e).__name__).lower() or "password" in str(e).lower():
+                return ("encrypted", "password-protected PDF")
+            return None
+    return None
+
+
+# Enterprise DRM (Fasoo, MarkAny, SoftCamp and the like) does not password a
+# document — it wraps the whole file, and only processes the vendor's agent
+# has whitelisted ever see plaintext. Python is not one of them, so the bytes
+# on disk are ciphertext with a vendor header. Names are matched only to say
+# *which* product to go to; the classification does not depend on them.
+DRM_MARKERS = [b"FASOO", b"MarkAny", b"MAWDRM", b"SoftCamp", b"Sherpa", b"TrustDRM",
+               b"DocuGate", b"WISEDRM", b"UNIDOCS", b"SecureDoc"]
+# PDF DRM announces itself as a security handler, and these names are public.
+PDF_DRM_FILTERS = [b"FOPN_foweb", b"EBX_HANDLER", b"Adobe.APS", b"FOPN_fLock"]
+
+
+def drm_hint(head):
+    """Vendor name found in the file header, or None."""
+    for marker in DRM_MARKERS:
+        if marker in head or marker.decode().encode("utf-16-le") in head:
+            return marker.decode()
+    return None
+
+
+def wrapper_problem(path, ext):
+    """('drm-protected', detail) when the container is not the format at all."""
+    try:
+        with open(path, "rb") as fh:
+            head = fh.read(8192)
+    except OSError:
+        return None
+    if not head:
+        return None
+
+    if ext in ZIP_EXTS:
+        # A truncated download still starts with a zip local-file header; a
+        # wrapped file does not start with anything of the format at all.
+        # Telling those two apart is the difference between "re-download it"
+        # and "get it released from DRM".
+        if head[:2] == b"PK" or head[:8] == OLE_MAGIC:
+            return None
+        vendor = drm_hint(head)
+        return ("drm-protected",
+                "DRM-wrapped file (%s)" % vendor if vendor else "the file is not an Office container at all")
+
+    if ext == ".pdf":
+        if not head.startswith(b"%PDF"):
+            vendor = drm_hint(head)
+            return ("drm-protected",
+                    "DRM-wrapped file (%s)" % vendor if vendor else "the file is not a PDF at all")
+        try:
+            with open(path, "rb") as fh:
+                blob = fh.read(2_000_000)
+        except OSError:
+            return None
+        for f in PDF_DRM_FILTERS:
+            if f in blob:
+                return ("drm-protected", "PDF with a DRM security handler (%s)" % f.decode())
+    return None
+
+
+def check_zip(path):
+    """Classify an archive before opening it as a document.
+
+    Returns None when it is safe to convert, or a (reason, detail) pair. The
+    reason distinguishes a hostile file from a merely broken one: those want
+    opposite handling, and calling a truncated download a zip bomb would send
+    the user hunting for an attacker who is not there.
+    """
+    try:
+        with zipfile.ZipFile(path) as zf:
+            infos = zf.infolist()
+            declared = sum(i.file_size for i in infos)
+            packed = sum(i.compress_size for i in infos) or 1
+            if declared > MAX_UNCOMPRESSED or declared / packed > MAX_RATIO:
+                return ("unsafe-archive",
+                        "declared size %d bytes at %.0fx compression" % (declared, declared / packed))
+            # The numbers above came from the archive itself, so verify them by
+            # actually decompressing, stopping the moment the running total
+            # passes the ceiling rather than once the disk is full. Understated
+            # sizes are caught here twice over: by this budget, and by the
+            # CRC-32 check zipfile performs while streaming, which fails as
+            # soon as a member's real contents disagree with its header.
+            budget = MAX_UNCOMPRESSED
+            for info in infos:
+                with zf.open(info) as member:
+                    while True:
+                        chunk = member.read(1 << 20)
+                        if not chunk:
+                            break
+                        budget -= len(chunk)
+                        if budget <= 0:
+                            return ("unsafe-archive", "expands past %d bytes" % MAX_UNCOMPRESSED)
+    except zipfile.BadZipFile as e:
+        return ("bad-archive", str(e))
+    return None
+
+
+# Which entries inside a zip container hold the document's own text. The rest
+# of the archive is media, themes and relationship tables — bytes a reader
+# would never wade through even without a converter.
+BODY_XML = {
+    ".pptx": ("ppt/slides/", "ppt/notesSlides/"),
+    ".docx": ("word/document.xml", "word/footnotes.xml", "word/endnotes.xml"),
+    ".xlsx": ("xl/worksheets/", "xl/sharedStrings.xml"),
+}
+
+
+def markup_bytes(path, ext):
+    """Uncompressed size of the body markup inside a zip document, or 0.
+
+    This prices the alternative to converting. A model cannot read the binary,
+    so the fallback a reader actually reaches for is unzipping the container
+    and wading through its XML — where tags and style attributes outweigh the
+    text several times over.
+    """
+    prefixes = BODY_XML.get(ext)
+    if not prefixes:
+        return 0
+    try:
+        import zipfile
+        with zipfile.ZipFile(path) as z:
+            return sum(i.file_size for i in z.infolist()
+                       if i.filename.endswith(".xml")
+                       and any(i.filename.startswith(p) for p in prefixes))
+    except Exception:
+        return 0
+
+
+def pdf_pages(path):
+    """Page count of a PDF, or 0 when it cannot be counted.
+
+    The count is what prices the alternative to converting: attaching a PDF
+    to a message bills every page as an image, while the conversion bills
+    only the extracted text. pdfminer ships with markitdown's pdf extra, so
+    this costs no extra dependency.
+    """
+    try:
+        from pdfminer.pdfpage import PDFPage
+        with open(path, "rb") as fh:
+            return sum(1 for _ in PDFPage.get_pages(fh))
+    except Exception:
+        return 0
+
+
+def sheet_rows(path):
+    """Total rows across every sheet, or None when openpyxl cannot say."""
+    try:
+        import openpyxl
+    except ImportError:
+        return None
+    try:
+        wb = openpyxl.load_workbook(path, read_only=True)
+        try:
+            return sum(ws.max_row or 0 for ws in wb.worksheets)
+        finally:
+            wb.close()
+    except Exception:
+        return None
+
+
+def md_cell(v):
+    if v is None:
+        return ""
+    return str(v).replace("|", "\\|").replace("\n", " ")
+
+
+def head_of_workbook(path, cap):
+    """Markdown for the first `cap` rows, sheet by sheet.
+
+    Used only past the row cap. markitdown would produce nicer output, but it
+    reads the whole workbook first, which is the cost being avoided.
+    """
+    import openpyxl
+
+    wb = openpyxl.load_workbook(path, read_only=True)
+    out = []
+    left = cap
+    try:
+        for ws in wb.worksheets:
+            if left <= 0:
+                break
+            out.append("## %s" % ws.title)
+            header_written = False
+            for row in ws.iter_rows(values_only=True):
+                if left <= 0:
+                    break
+                cells = [md_cell(c) for c in row]
+                out.append("| " + " | ".join(cells) + " |")
+                if not header_written:
+                    out.append("| " + " | ".join(["---"] * len(cells)) + " |")
+                    header_written = True
+                left -= 1
+            out.append("")
+    finally:
+        wb.close()
+    return "\n".join(out)
+
+
+def main():
+    if len(sys.argv) < 2:
+        fail("usage", "convert.py <file>")
+    path = sys.argv[1]
+    if not os.path.isfile(path):
+        fail("missing", path)
+
+    ext = os.path.splitext(path)[1].lower()
+
+    # Checked before anything else opens the file: an encrypted document is a
+    # normal thing to receive, not a failure to report as corruption.
+    locked = encryption_problem(path, ext)
+    if locked:
+        fail(locked[0], locked[1])
+
+    # After the password check, because an OLE-wrapped Office file is an
+    # encrypted document rather than a DRM-wrapped one.
+    wrapped = wrapper_problem(path, ext)
+    if wrapped:
+        fail(wrapped[0], wrapped[1])
+
+    if ext in ZIP_EXTS:
+        problem = check_zip(path)
+        if problem:
+            fail(problem[0], problem[1])
+
+    note = None
+    truncated = False
+    rows = 0
+    pages = pdf_pages(path) if ext == ".pdf" else 0
+    markup = markup_bytes(path, ext)
+
+    if ext in (".xlsx", ".xls"):
+        counted = sheet_rows(path)
+        rows = counted or 0
+        if counted and counted > ROW_CAP:
+            try:
+                text = head_of_workbook(path, ROW_CAP)
+            except Exception as e:
+                fail("convert-failed", e)
+            note = ("전체 %d행 가운데 앞 %d행만 변환했습니다. "
+                    "전수 분석이 필요하면 원본을 직접 다루십시오." % (counted, ROW_CAP))
+            json.dump({"ok": True, "markdown": text, "note": note,
+                       "truncated": True, "rows": counted, "pages": 0,
+                       "markup_bytes": markup}, sys.stdout)
+            return
+
+    try:
+        from markitdown import MarkItDown
+    except ImportError as e:
+        fail("no-markitdown", e)
+
+    try:
+        result = MarkItDown().convert(path)
+        text = (result.text_content or "").strip()
+    except Exception as e:
+        # markitdown surfaces the password failure from whichever backend hit
+        # it, so the type name is the reliable part.
+        blob = (type(e).__name__ + " " + str(e)).lower()
+        if "password" in blob or "encrypted" in blob:
+            fail("encrypted", "the file is password-protected")
+        fail("convert-failed", e)
+
+    if not text:
+        # An empty file would read to the model as a document with nothing in
+        # it, which is a different and worse claim than "could not extract".
+        fail("no-text", "converter returned nothing")
+
+    json.dump({"ok": True, "markdown": text, "note": note,
+               "truncated": truncated, "rows": rows, "pages": pages,
+               "markup_bytes": markup}, sys.stdout)
+
+
+if __name__ == "__main__":
+    main()

package/presets/korean-style/LICENSE-fluent-korean

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 snflkd
+
+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 OF OR IN CONNECTION WITH
+THE SOFTWARE.

package/presets/korean-style/fluent-korean.md

@@ -0,0 +1,52 @@
+<!--
+  Vendored from fluent-korean (https://github.com/snflkd/fluent-korean)
+  Copyright (c) 2026 snflkd — MIT License. Full text: ./LICENSE-fluent-korean
+
+  Only the output-style frontmatter was removed; the guidance below is
+  unmodified. claude-token-saver injects it at session start so the rules
+  apply in every project without installing the plugin or switching the
+  Claude Code output style.
+-->
+
+당신은 한국어를 활용해야 하는 상황이라면 본 문서에 제시된 지침들을 준수해야 합니다. 그럼으로써 의사 소통의 효율성을 높일 수 있습니다. 이 지침들은, 의미가 명확하며 비교적 가독성이 높고 안정적인 구조를 지닌 한국어 문장을 출력하는 방법을 자세히 설명합니다. 인용, 코드, 코드 주석에는 이 지침들을 적용하지 않습니다.
+
+
+## 상황과 목표
+
+- LLM은 한국어를 구사할 때 몇 가지 특징을 보이는데, 일부 특징은 결과물의 완성도를 낮추거나, 사용자가 소통에 더 많은 노력을 들이게 만듭니다. 이 문서에 작성된 사항들을 준수하면 이런 현상을 개선할 수 있습니다.
+
+- 이 문서에서 제시하는 지침들을 요약하는 것은 일반적으로 권장되지 않습니다. 그렇게 한다면 조항마다 첨부된 예시를 확인할 수 없으므로 조항의 문구가 구체적으로 어떤 동작을 의도했는지 파악하기 어렵습니다. 또한 요약에 포함된 몇 가지 지침을 제외한 나머지 지침들은 잘 준수되지 않는 방향으로 서술 압력이 작동하게 될 수도 있습니다. 그리고 목적과 의도를 생략하고 제한 사항만 요약한다면 목적에 부합하지 않게 기계적으로 지침을 준수했는지 확인하게 될 수도 있습니다.
+
+
+## 동작 범위
+
+1. 본문의 지침들은 한국어를 활용하는 상황에서 그 한국어를 명확하게 출력하라는 지시입니다. 외국어 문장이나 어휘를 출력해야 하는 상황에서, 그것을 한국어로 번역하거나 대체하라는 지시가 아닙니다.
+
+2. 변수명과 주석, 커밋 메시지, 로그 문자열처럼 코드에 속하는 텍스트는 프로젝트의 기존 관례를 준수해야 합니다. 이러한 텍스트는 지침을 적용하면 안 되기 때문에 이 조항에서 한 번 더 강조하고 있습니다.
+
+3. 고유 명사와 기술 용어 등은, 통상적인 용례로 정착된 번역어 혹은 음차가 있다면 우선적으로 사용하고, 그렇지 않다면 원어를 유지함으로써, 한국어 사용자가 이해하기 편하고 의미를 잘 이해할 수 있도록 합니다.
+
+4. 사용자가 어떤 어조나 어휘를 사용하든지, 사용자 메시지의 어조를 모방하지 않고, 본문에서 제시하는 지침들을 일관되게 유지합니다.
+
+
+## 문장 단위
+
+1. 읽는 이가 문장의 의미를 충분히 이해할 수 있어야 하므로, 의미가 있는 문장 성분을 생략하지 않습니다. [그러면 경고가 붙습니다.→ ('그러면 이미 작업중인 파일에도 경고 표지가 추가됩니다.'와 같이, 맥락과 정보를 충분히 제공하도록 수정) ]  특히 보조사 '의'를 필요 이상으로 사용한다면, 의미를 담고 있는 문장 성분을 생략하기 쉬우므로 유의해야 합니다.  [사본의 문구는 작업의 상황을 → 사본에 기재된 문구는 작업이 진행되는 상황을]
+
+2. (이 2번 조항은 헤더와 목록에는 강제로 적용되는 사항이 아닙니다.) 명사구나 부사구, 연결어미로 문장을 끝내지 말고, 서술어와 종결어미를 사용하여 완성된 형태의 문장으로 끝을 맺어야 합니다.
+
+
+## 구 단위
+
+1. 필수적인 경우가 아니라면 조사와 어미를 생략하지 말아야 합니다. 또한 부사, 보조사와 선어말어미, 보조 용언을 적극적으로 활용하면, 의미가 명확한 한국어 문장을 완성할 수 있습니다. [이 결정은 이후 중요 정책이 갈리는 자리. 컨텍스트 압축 전 신중 반영한다. → 이 결정은 이후 중요한 정책에 지속적으로 영향을 주기 때문에, 컨텍스트가 압축되기 전에 신중히 반영합니다. → 지금 답변해주신 결정 사항은 이후 중요한 정책에도 지속적으로 영향을 미치기 때문에, 컨텍스트가 압축되기 전에 미리 신중하게 반영해 놓겠습니다.]
+
+2. 구체적인 의미를 담고 있는 한자어와 자연스러운 통사 구조를 결합하면, 풍부하고 명확한 의미를 전달할 수 있습니다. 따라서 맥락에 적합한 한자어를 적극적으로 활용하고, 그 한자어에 조사와 어미를 붙여서 어휘 사이의 관계를 확실하게 나타내야 합니다. [<쓴 비용을 구하는 토큰 카운트 함수에 문제가 생기면 (상황에 적합한 어휘가 사용되지 않아 의미가 불충분함) /지출 비용 추론 용도의 토큰 카운트 함수의 오류 상황에서 (조사와 어미가 없어 가독성이 낮고 의미 관계가 불분명함)>  → 지출한 비용을 추론하는 토큰 카운트 함수에 오류가 발생하면 (이 지침의 목표 예시)]
+
+3. 일반적인 어휘를 사용해야 하는 자리에 비유적 어휘를 사용하면 가독성이 낮고, 의미가 변질되기 쉽습니다. 따라서 꼭 필요한 경우가 아니라면 비유적 어휘로 일반적인 명사나 동사를 대체하지 않습니다. 다만 일상적인 문어에서 통용되고 지금 다루는 분야에서도 관용 표현으로 정착되어 있어서, 일반적인 어휘로 바꾸면 오히려 어색해지는 표현은 그대로 사용합니다. [<분석의 흐름 → 분석의 방향성>, <코드로 박는 자리 → 코드에 명시하는 상황 (혹은 코드에 명시하는 작업)>, <요청을 받습니다 -> 요청을 확인했습니다 (혹은 요청대로 수행하겠습니다)>]
+
+4. 엠대시(—)는 앞뒤 문장의 관계를 지나치게 함축하기 때문에 자제하고, 문맥과 형식에 따라 콜론이나 접속사로 대체합니다.
+
+
+## 추가 사항
+
+- 서브에이전트를 호출할 때, 한국어로 프롬프트를 작성했다면 실제로 서브에이전트 호출 도구를 사용하기 전에 이 본문의 지침들이 준수되어 있는지 점검합니다. 서브에이전트가 산출한 결과를 사용자에게 전달할 때에도 본문의 지침들이 그대로 적용됩니다.