@kkelly-offical/kkcode 0.1.6 → 0.2.1

package/src/session/system-prompt.mjs

@@ -4,6 +4,7 @@ import path from "node:path"
 import { fileURLToPath } from "node:url"
 import { createHash } from "node:crypto"
 import { loadSessionPrompt } from "./prompt-loader.mjs"
+import { renderPublicModeContract } from "./engine.mjs"
 import { getAgentPrompt, listAgents } from "../agent/agent.mjs"
 import { loadAutoMemory } from "./memory-loader.mjs"
 
@@ -95,8 +96,14 @@ export async function agentPrompt(agent) {
 
 // Layer 4: Mode reminder (stable within mode)
 export async function modeReminder(mode) {
-  if (mode === "plan") return loadSessionPrompt("plan.txt")
-  return ""
+  const contractBlock = renderPublicModeContract()
+  if (mode === "assistant") return `${contractBlock}\n\nAssistant mode active. Treat this as the default CLI personal assistant lane for bounded terminal-native work: local files, logs, system checks, web lookup, Git/GitHub assistance, notes, task organization, and lightweight automation. Escalate to agent/code for explicit coding mutations and to longagent for staged multi-file delivery.`
+  if (mode === "plan") return `${contractBlock}\n\n${await loadSessionPrompt("plan.txt")}`
+  if (mode === "agent") return `${contractBlock}\n\n${await loadSessionPrompt("agent.txt")}\n\nCoding lane active. Focus on inspect/patch/verify coding work, keep diffs small, and validate with the narrowest useful tests.`
+  if (mode === "longagent") {
+    return `${contractBlock}\n\nLongAgent mode active. Treat this as the heavyweight staged delivery lane for multi-file or system-level work. Keep explicit gates, ownership, and recovery behavior intact.`
+  }
+  return contractBlock
 }
 
 // Layer 5: Tool descriptions (stable across session — ideal cache target)
@@ -138,7 +145,7 @@ export async function buildSystemPromptBlocks({ mode, model, cwd, agent = null,
     agent: agent?.name || null,
     tools: tools.map(t => t.name).sort(),
     skills: skills.map(s => s.name).sort(),
-    userInstructions: userInstructions.slice(0, 200) // first 200 chars as fingerprint
+    userInstructions: hashInputs({ ui: userInstructions }) // hash full string to avoid collisions
   })
 
   if (blockCache.key === cacheKey && blockCache.result) {
@@ -187,14 +194,55 @@ export async function buildSystemPromptBlocks({ mode, model, cwd, agent = null,
     blocks.push({ label: "tools", text: toolText, cacheable: true })
   }
 
-  // Block 4: Skills descriptions (stable — changes only when skills change)
+  // Block 3.5: Large output strategy (stable — always included)
+  const outputStrategyLines = [
+    "# Large Output Strategy",
+    "",
+    "When generating large amounts of content:",
+    "- For large file creation, write no more than 200 lines per tool call; use append mode for subsequent chunks",
+    "- For partial file edits, use patch with line ranges instead of rewriting the whole file",
+    "- If a task requires more than 300 lines of code, proactively split into multiple sequential tool calls",
+    "- Never attempt to write an entire large file in a single tool call"
+  ]
+  blocks.push({ label: "output_strategy", text: outputStrategyLines.join("\n"), cacheable: true })
+
+  // Block 4: CLI assistant contract (stable — release-facing behavior boundary)
+  const assistantContractLines = [
+    "# CLI Assistant Contract",
+    "",
+    "Operate as a CLI-first personal assistant, not an IDE shell or GUI automation product.",
+    "",
+    "Prefer the lightest path that completes the next step well:",
+    "- answer directly for short questions",
+    "- treat assistant as the default lane for bounded terminal-native personal assistant work",
+    "- treat agent/code/coding as the dedicated lane for coding mutation, debugging, refactoring, and test repair",
+    "- handle small local inspect/run/summarize tasks without over-upgrading to heavyweight execution",
+    "- continue an interrupted local transaction when the follow-up still fits the same bounded scope",
+    "- reserve longagent-style behavior for structured multi-file or system-level delivery with explicit heavy evidence",
+    "",
+    "Current safe capability boundary:",
+    "- coding and patching",
+    "- local filesystem, config, and log inspection",
+    "- shell/task execution",
+    "- repo/release assistance",
+    "- web lookup/fetch",
+    "- bounded delegated sidecar work",
+    "",
+    "Do not imply unsupported product surfaces such as GUI desktop automation, IDE integration, marketplace installs, or remote bridge platforms."
+  ]
+  blocks.push({ label: "assistant_contract", text: assistantContractLines.join("\n"), cacheable: true })
+
+  // Block 4.5: Public mode contract (stable — keeps assistant/plan/agent/longagent aligned)
+  blocks.push({ label: "mode_contract", text: renderPublicModeContract(), cacheable: true })
+
+  // Block 5: Skills descriptions (stable — changes only when skills change)
   if (skills.length) {
     const skillLines = skills.map((s) => `- /${s.name}: ${s.description || s.name}`).join("\n")
     const skillText = `# Available Skills\n\nInvoke with /<skill-name> [arguments].\n\n${skillLines}`
     blocks.push({ label: "skills", text: skillText, cacheable: true })
   }
 
-  // Block 4.5: Available sub-agents (stable — changes only when custom agents change)
+  // Block 5.5: Available sub-agents (stable — changes only when custom agents change)
   const allAgents = listAgents({ includeHidden: false })
   const customSubagents = allAgents.filter((a) => a.mode === "subagent" && a._customAgent)
   if (customSubagents.length) {
@@ -213,12 +261,12 @@ export async function buildSystemPromptBlocks({ mode, model, cwd, agent = null,
     blocks.push({ label: "subagents", text: subagentText, cacheable: true })
   }
 
-  // Block 4.7: Project context (semi-stable — changes when cwd changes)
+  // Block 5.7: Project context (semi-stable — changes when cwd changes)
   if (projectContext) {
     blocks.push({ label: "project", text: projectContext, cacheable: false })
   }
 
-  // Block 4.9: Language constraint (stable — changes only when config changes)
+  // Block 5.9: Language constraint (stable — changes only when config changes)
   if (language && language !== "en") {
     const langMap = {
       zh: "Always respond in Chinese (中文). Use Chinese for all explanations, comments, and communications. Technical terms, code identifiers, and code content should remain in their original form (typically English)."
@@ -229,7 +277,7 @@ export async function buildSystemPromptBlocks({ mode, model, cwd, agent = null,
     }
   }
 
-  // Block 4.95: Auto Memory (semi-stable — changes when user updates memory files)
+  // Block 5.95: Auto Memory (semi-stable — changes when user updates memory files)
   const memoryText = await loadAutoMemory(cwd)
   if (memoryText) {
     blocks.push({ label: "memory", text: memoryText, cacheable: false })

package/src/session/task-validator.mjs

@@ -1,267 +1,267 @@
-import { exec as execCb, execFile as execFileCb } from "node:child_process"
-import { promisify } from "node:util"
-import { access, readFile } from "node:fs/promises"
-import path from "node:path"
-
-const exec = promisify(execCb)
-const execFile = promisify(execFileCb)
-
-async function fileExists(p) {
-  try { await access(p); return true } catch { return false }
-}
-
-export class TaskValidator {
-  constructor({ cwd, configState }) {
-    this.cwd = cwd
-    this.configState = configState
-  }
-
-  async checkTodoCompletion(todoState) {
-    if (!todoState || !Array.isArray(todoState)) {
-      return {
-        passed: true,
-        message: "No todo list found"
-      }
-    }
-
-    const incomplete = todoState.filter(t => t.status !== "completed")
-    if (incomplete.length === 0) {
-      return {
-        passed: true,
-        message: "All todo items completed"
-      }
-    }
-
-    const items = incomplete.map(t => `- ${t.content}`).join("\n")
-    return {
-      passed: false,
-      message: `Incomplete todo items:\n${items}`
-    }
-  }
-
-  async checkJavaScriptSyntax() {
-    const jsFiles = await this.findFilesByExtension(["js", "mjs", "cjs"])
-    if (jsFiles.length === 0) {
-      return {
-        passed: true,
-        message: "No JavaScript files to check"
-      }
-    }
-
-    const errors = []
-    for (const file of jsFiles.slice(0, 20)) {
-      try {
-        await execFile("node", ["--check", file], { cwd: this.cwd, timeout: 10000 })
-      } catch (error) {
-        errors.push(`${file}: ${(error.stderr || error.message || "").trim()}`)
-      }
-    }
-
-    return {
-      passed: errors.length === 0,
-      message: errors.length === 0 ? "JavaScript syntax check passed" : `JavaScript syntax errors:\n${errors.join("\n")}`
-    }
-  }
-
-  async checkTypeScript() {
-    const tsconfigPath = path.join(this.cwd, "tsconfig.json")
-    if (!(await fileExists(tsconfigPath))) {
-      return {
-        passed: true,
-        message: "No tsconfig.json found"
-      }
-    }
-
-    try {
-      await exec("npx tsc --noEmit", {
-        cwd: this.cwd,
-        timeout: 30000
-      })
-      return {
-        passed: true,
-        message: "TypeScript check passed"
-      }
-    } catch (error) {
-      const output = (error.stdout || error.stderr || "").trim()
-      return {
-        passed: false,
-        message: `TypeScript errors:\n${output.slice(0, 2000)}`
-      }
-    }
-  }
-
-  async checkPythonSyntax() {
-    const pyFiles = await this.findFilesByExtension(["py"])
-    if (pyFiles.length === 0) {
-      return {
-        passed: true,
-        message: "No Python files to check"
-      }
-    }
-
-    const errors = []
-    for (const file of pyFiles.slice(0, 20)) {
-      try {
-        await execFile("python", ["-m", "py_compile", file], { cwd: this.cwd, timeout: 10000 })
-      } catch (error) {
-        errors.push(`${file}: ${(error.stderr || error.message || "").trim()}`)
-      }
-    }
-
-    return {
-      passed: errors.length === 0,
-      message: errors.length === 0 ? "Python syntax check passed" : `Python syntax errors:\n${errors.join("\n")}`
-    }
-  }
-
-  async runTests() {
-    const packageJsonPath = path.join(this.cwd, "package.json")
-    if (!(await fileExists(packageJsonPath))) {
-      return {
-        passed: true,
-        message: "No package.json found"
-      }
-    }
-
-    try {
-      const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"))
-      const hasTestScript = packageJson.scripts?.test
-      if (!hasTestScript) {
-        return {
-          passed: true,
-          message: "No test script found"
-        }
-      }
-
-      await exec("npm test", {
-        cwd: this.cwd,
-        timeout: 120000
-      })
-      return {
-        passed: true,
-        message: "Tests passed"
-      }
-    } catch (error) {
-      const output = (error.stdout || error.stderr || "").trim()
-      return {
-        passed: false,
-        message: `Test failures:\n${output.slice(0, 2000)}`
-      }
-    }
-  }
-
-  async findFilesByExtension(extensions) {
-    const files = []
-    for (const ext of extensions) {
-      try {
-        const matches = await this.globPattern(`**/*.${ext}`)
-        files.push(...matches)
-      } catch {
-      }
-    }
-    return files
-  }
-
-  async globPattern(pattern) {
-    try {
-      const { Glob } = await import("glob")
-      const g = new Glob(pattern, {
-        cwd: this.cwd,
-        ignore: ["node_modules/**", ".git/**", "dist/**", "build/**"]
-      })
-      const matches = []
-      for await (const match of g) {
-        matches.push(path.join(this.cwd, match))
-      }
-      return matches
-    } catch {
-      return []
-    }
-  }
-
-  async checkBuild() {
-    const packageJsonPath = path.join(this.cwd, "package.json")
-    if (!(await fileExists(packageJsonPath))) {
-      return { passed: true, message: "No package.json found", severity: "skip" }
-    }
-    try {
-      const pkg = JSON.parse(await readFile(packageJsonPath, "utf8"))
-      if (!pkg.scripts?.build) {
-        return { passed: true, message: "No build script", severity: "skip" }
-      }
-      await exec("npm run build --silent", { cwd: this.cwd, timeout: 60000 })
-      return { passed: true, message: "Build succeeded", severity: "pass" }
-    } catch (error) {
-      const output = (error.stdout || error.stderr || "").trim()
-      return { passed: false, message: `Build failed:\n${output.slice(0, 1500)}`, severity: "critical" }
-    }
-  }
-
-  async checkLint() {
-    const packageJsonPath = path.join(this.cwd, "package.json")
-    if (!(await fileExists(packageJsonPath))) {
-      return { passed: true, message: "No package.json found", severity: "skip" }
-    }
-    try {
-      const pkg = JSON.parse(await readFile(packageJsonPath, "utf8"))
-      if (!pkg.scripts?.lint) {
-        return { passed: true, message: "No lint script", severity: "skip" }
-      }
-      await exec("npm run lint --silent", { cwd: this.cwd, timeout: 30000 })
-      return { passed: true, message: "Lint passed", severity: "pass" }
-    } catch (error) {
-      const output = (error.stdout || error.stderr || "").trim()
-      return { passed: false, message: `Lint issues:\n${output.slice(0, 1500)}`, severity: "warning" }
-    }
-  }
-
-  async validate({ todoState, level = "standard" }) {
-    const results = []
-
-    const todoResult = await this.checkTodoCompletion(todoState)
-    results.push({ name: "Todo", ...todoResult, severity: todoResult.passed ? "pass" : "critical" })
-
-    const jsResult = await this.checkJavaScriptSyntax()
-    results.push({ name: "JS Syntax", ...jsResult, severity: jsResult.passed ? "pass" : "critical" })
-
-    if (level !== "quick") {
-      const tsResult = await this.checkTypeScript()
-      results.push({ name: "TypeScript", ...tsResult, severity: tsResult.passed ? "pass" : "critical" })
-
-      const buildResult = await this.checkBuild()
-      results.push({ name: "Build", ...buildResult })
-
-      const testResult = await this.runTests()
-      results.push({ name: "Tests", ...testResult, severity: testResult.passed ? "pass" : "critical" })
-    }
-
-    if (level === "strict") {
-      const lintResult = await this.checkLint()
-      results.push({ name: "Lint", ...lintResult })
-
-      const pyResult = await this.checkPythonSyntax()
-      results.push({ name: "Python", ...pyResult, severity: pyResult.passed ? "pass" : "warning" })
-    }
-
-    const critical = results.filter(r => !r.passed && r.severity === "critical").length
-    const warnings = results.filter(r => !r.passed && r.severity === "warning").length
-    const verdict = critical > 0 ? "BLOCK" : warnings > 0 ? "WARNING" : "APPROVE"
-    const allPassed = verdict !== "BLOCK"
-
-    const lines = [
-      "VERIFICATION REPORT",
-      "===================",
-      ...results.map(r => `${r.passed ? "PASS" : "FAIL"} ${r.name}: ${r.message}`),
-      "",
-      `VERDICT: ${verdict}`,
-      `CRITICAL: ${critical}  WARNING: ${warnings}`,
-      allPassed ? "Ready to proceed." : "Must fix critical issues before proceeding."
-    ]
-
-    return { passed: allPassed, verdict, results, message: lines.join("\n") }
-  }
-}
-
-export async function createValidator({ cwd, configState }) {
-  return new TaskValidator({ cwd, configState })
-}
+import { exec as execCb, execFile as execFileCb } from "node:child_process"
+import { promisify } from "node:util"
+import { access, readFile } from "node:fs/promises"
+import path from "node:path"
+
+const exec = promisify(execCb)
+const execFile = promisify(execFileCb)
+
+async function fileExists(p) {
+  try { await access(p); return true } catch { return false }
+}
+
+export class TaskValidator {
+  constructor({ cwd, configState }) {
+    this.cwd = cwd
+    this.configState = configState
+  }
+
+  async checkTodoCompletion(todoState) {
+    if (!todoState || !Array.isArray(todoState)) {
+      return {
+        passed: true,
+        message: "No todo list found"
+      }
+    }
+
+    const incomplete = todoState.filter(t => t.status !== "completed")
+    if (incomplete.length === 0) {
+      return {
+        passed: true,
+        message: "All todo items completed"
+      }
+    }
+
+    const items = incomplete.map(t => `- ${t.content}`).join("\n")
+    return {
+      passed: false,
+      message: `Incomplete todo items:\n${items}`
+    }
+  }
+
+  async checkJavaScriptSyntax() {
+    const jsFiles = await this.findFilesByExtension(["js", "mjs", "cjs"])
+    if (jsFiles.length === 0) {
+      return {
+        passed: true,
+        message: "No JavaScript files to check"
+      }
+    }
+
+    const errors = []
+    for (const file of jsFiles.slice(0, 20)) {
+      try {
+        await execFile("node", ["--check", file], { cwd: this.cwd, timeout: 10000 })
+      } catch (error) {
+        errors.push(`${file}: ${(error.stderr || error.message || "").trim()}`)
+      }
+    }
+
+    return {
+      passed: errors.length === 0,
+      message: errors.length === 0 ? "JavaScript syntax check passed" : `JavaScript syntax errors:\n${errors.join("\n")}`
+    }
+  }
+
+  async checkTypeScript() {
+    const tsconfigPath = path.join(this.cwd, "tsconfig.json")
+    if (!(await fileExists(tsconfigPath))) {
+      return {
+        passed: true,
+        message: "No tsconfig.json found"
+      }
+    }
+
+    try {
+      await exec("npx tsc --noEmit", {
+        cwd: this.cwd,
+        timeout: 30000
+      })
+      return {
+        passed: true,
+        message: "TypeScript check passed"
+      }
+    } catch (error) {
+      const output = (error.stdout || error.stderr || "").trim()
+      return {
+        passed: false,
+        message: `TypeScript errors:\n${output.slice(0, 2000)}`
+      }
+    }
+  }
+
+  async checkPythonSyntax() {
+    const pyFiles = await this.findFilesByExtension(["py"])
+    if (pyFiles.length === 0) {
+      return {
+        passed: true,
+        message: "No Python files to check"
+      }
+    }
+
+    const errors = []
+    for (const file of pyFiles.slice(0, 20)) {
+      try {
+        await execFile("python", ["-m", "py_compile", file], { cwd: this.cwd, timeout: 10000 })
+      } catch (error) {
+        errors.push(`${file}: ${(error.stderr || error.message || "").trim()}`)
+      }
+    }
+
+    return {
+      passed: errors.length === 0,
+      message: errors.length === 0 ? "Python syntax check passed" : `Python syntax errors:\n${errors.join("\n")}`
+    }
+  }
+
+  async runTests() {
+    const packageJsonPath = path.join(this.cwd, "package.json")
+    if (!(await fileExists(packageJsonPath))) {
+      return {
+        passed: true,
+        message: "No package.json found"
+      }
+    }
+
+    try {
+      const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"))
+      const hasTestScript = packageJson.scripts?.test
+      if (!hasTestScript) {
+        return {
+          passed: true,
+          message: "No test script found"
+        }
+      }
+
+      await exec("npm test", {
+        cwd: this.cwd,
+        timeout: 120000
+      })
+      return {
+        passed: true,
+        message: "Tests passed"
+      }
+    } catch (error) {
+      const output = (error.stdout || error.stderr || "").trim()
+      return {
+        passed: false,
+        message: `Test failures:\n${output.slice(0, 2000)}`
+      }
+    }
+  }
+
+  async findFilesByExtension(extensions) {
+    const files = []
+    for (const ext of extensions) {
+      try {
+        const matches = await this.globPattern(`**/*.${ext}`)
+        files.push(...matches)
+      } catch {
+      }
+    }
+    return files
+  }
+
+  async globPattern(pattern) {
+    try {
+      const { Glob } = await import("glob")
+      const g = new Glob(pattern, {
+        cwd: this.cwd,
+        ignore: ["node_modules/**", ".git/**", "dist/**", "build/**"]
+      })
+      const matches = []
+      for await (const match of g) {
+        matches.push(path.join(this.cwd, match))
+      }
+      return matches
+    } catch {
+      return []
+    }
+  }
+
+  async checkBuild() {
+    const packageJsonPath = path.join(this.cwd, "package.json")
+    if (!(await fileExists(packageJsonPath))) {
+      return { passed: true, message: "No package.json found", severity: "skip" }
+    }
+    try {
+      const pkg = JSON.parse(await readFile(packageJsonPath, "utf8"))
+      if (!pkg.scripts?.build) {
+        return { passed: true, message: "No build script", severity: "skip" }
+      }
+      await exec("npm run build --silent", { cwd: this.cwd, timeout: 60000 })
+      return { passed: true, message: "Build succeeded", severity: "pass" }
+    } catch (error) {
+      const output = (error.stdout || error.stderr || "").trim()
+      return { passed: false, message: `Build failed:\n${output.slice(0, 1500)}`, severity: "critical" }
+    }
+  }
+
+  async checkLint() {
+    const packageJsonPath = path.join(this.cwd, "package.json")
+    if (!(await fileExists(packageJsonPath))) {
+      return { passed: true, message: "No package.json found", severity: "skip" }
+    }
+    try {
+      const pkg = JSON.parse(await readFile(packageJsonPath, "utf8"))
+      if (!pkg.scripts?.lint) {
+        return { passed: true, message: "No lint script", severity: "skip" }
+      }
+      await exec("npm run lint --silent", { cwd: this.cwd, timeout: 30000 })
+      return { passed: true, message: "Lint passed", severity: "pass" }
+    } catch (error) {
+      const output = (error.stdout || error.stderr || "").trim()
+      return { passed: false, message: `Lint issues:\n${output.slice(0, 1500)}`, severity: "warning" }
+    }
+  }
+
+  async validate({ todoState, level = "standard" }) {
+    const results = []
+
+    const todoResult = await this.checkTodoCompletion(todoState)
+    results.push({ name: "Todo", ...todoResult, severity: todoResult.passed ? "pass" : "critical" })
+
+    const jsResult = await this.checkJavaScriptSyntax()
+    results.push({ name: "JS Syntax", ...jsResult, severity: jsResult.passed ? "pass" : "critical" })
+
+    if (level !== "quick") {
+      const tsResult = await this.checkTypeScript()
+      results.push({ name: "TypeScript", ...tsResult, severity: tsResult.passed ? "pass" : "critical" })
+
+      const buildResult = await this.checkBuild()
+      results.push({ name: "Build", ...buildResult })
+
+      const testResult = await this.runTests()
+      results.push({ name: "Tests", ...testResult, severity: testResult.passed ? "pass" : "critical" })
+    }
+
+    if (level === "strict") {
+      const lintResult = await this.checkLint()
+      results.push({ name: "Lint", ...lintResult })
+
+      const pyResult = await this.checkPythonSyntax()
+      results.push({ name: "Python", ...pyResult, severity: pyResult.passed ? "pass" : "warning" })
+    }
+
+    const critical = results.filter(r => !r.passed && r.severity === "critical").length
+    const warnings = results.filter(r => !r.passed && r.severity === "warning").length
+    const verdict = critical > 0 ? "BLOCK" : warnings > 0 ? "WARNING" : "APPROVE"
+    const allPassed = verdict !== "BLOCK"
+
+    const lines = [
+      "VERIFICATION REPORT",
+      "===================",
+      ...results.map(r => `${r.passed ? "PASS" : "FAIL"} ${r.name}: ${r.message}`),
+      "",
+      `VERDICT: ${verdict}`,
+      `CRITICAL: ${critical}  WARNING: ${warnings}`,
+      allPassed ? "Ready to proceed." : "Must fix critical issues before proceeding."
+    ]
+
+    return { passed: allPassed, verdict, results, message: lines.join("\n") }
+  }
+}
+
+export async function createValidator({ cwd, configState }) {
+  return new TaskValidator({ cwd, configState })
+}

package/src/session/usability-gates.mjs

@@ -1,14 +1,14 @@
 import path from "node:path"
 import { access, readFile, writeFile, mkdir } from "node:fs/promises"
-import { homedir } from "node:os"
 import { spawn } from "node:child_process"
 import { readReviewState } from "../review/review-store.mjs"
 import { fsckSessionStore, getSession } from "./store.mjs"
 import { EventBus } from "../core/events.mjs"
 import { EVENT_TYPES } from "../core/constants.mjs"
+import { userRootDir } from "../storage/paths.mjs"
 
 const DEFAULT_GATE_TIMEOUT_MS = 15 * 60 * 1000
-const GATE_PREFS_FILE = path.join(homedir(), ".kkcode", "gate-preferences.json")
+const GATE_PREFS_FILE = path.join(userRootDir(), "gate-preferences.json")
 
 // --- Gate result cache (5-min TTL, only caches passing results) ---
 const gateCache = new Map()