thincoder 0.12.2 → 0.12.4

package/src/session.mjs

@@ -1,31 +1,71 @@
 /**
- * session.mjs — session persistence
- * Each project (keyed by cwd hash) keeps up to 5 session slots, rotated by last-access time.
- * Two recovery needs stored separately: agent recovery (history) needs context continuity, user recovery (display) needs WYSIWYG.
+ * session.mjs — session persistence (slot-based model)
+ * Each project (keyed by cwd hash) keeps unlimited session slots.
+ * Every session lives in a numbered slot; the manifest tracks which slot is active.
+ * There is no separate "current" file — the active slot IS the current session.
  *
- * File layout: {hash}.json (current), {hash}.json.1~5 (slots), {hash}.json.manifest (slot metadata)
+ * File layout: {hash}.json.N (slots), {hash}.json.manifest (slot metadata + active pointer).
+ * Legacy {hash}.json is migrated to a slot on first access.
  */
 
 import { createHash } from "node:crypto"
-import { mkdirSync, readFileSync, writeFileSync, renameSync, copyFileSync, unlinkSync, existsSync } from "node:fs"
+import { mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync, existsSync } from "node:fs"
 import { join, dirname } from "node:path"
+import { execSync } from "node:child_process"
 import { configDir } from "./config.mjs"
 
-const MAX_SLOTS = 5
-const CWD_HASH_LEN = 12
+let currentSessionId = null
 
-/** Derive session file path from cwd hash */
+/** Generate unique session ID for this process */
+export function getSessionId() {
+  if (!currentSessionId) {
+    currentSessionId = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+  }
+  return currentSessionId
+}
+
+/** Normalize cwd for hashing: uppercase Windows drive letter so both ends
+ *  (CLI's process.cwd() vs VS Code's uri.fsPath, which lowercases it) agree. */
+export function normalizeCwd(cwd) {
+  return cwd.replace(/^([a-z]):/, (_, d) => d.toUpperCase() + ":")
+}
+
+/** Full sha1 hex (40 chars), not truncated. Shared contract with the VS Code extension. */
+function cwdHash(cwd) {
+  return createHash("sha1").update(normalizeCwd(cwd)).digest("hex")
+}
+
+/** One-time migration: rename legacy 12-char-hash session files to the full 40-char hash.
+ *  Idempotent; runs on first access per cwd. */
+function migrateHashLength(cwd, fullHash) {
+  const dir = join(configDir, "sessions")
+  const legacyBase = join(dir, `${fullHash.slice(0, 12)}.json`)
+  if (!existsSync(legacyBase) && !existsSync(`${legacyBase}.manifest`) && !existsSync(`${legacyBase}.1`)) return
+  const newBase = join(dir, `${fullHash}.json`)
+  try {
+    for (const suffix of ["", ".manifest", ...Array.from({ length: 64 }, (_, i) => `.${i + 1}`)]) {
+      const from = legacyBase + suffix
+      if (existsSync(from) && !existsSync(newBase + suffix)) renameSync(from, newBase + suffix)
+    }
+  } catch { /* best-effort; leave files in place on failure */ }
+}
+
+/** Derive base session path from cwd hash. Migrates legacy short-hash files on first access. */
 export function sessionPath(cwd) {
-  const hash = createHash("sha1").update(cwd).digest("hex").slice(0, CWD_HASH_LEN)
+  const hash = cwdHash(cwd)
+  migrateHashLength(cwd, hash)
   return join(configDir, "sessions", `${hash}.json`)
 }
 
 function slotPath(cwd, n) { return sessionPath(cwd) + "." + n }
 function manifestPath(cwd) { return sessionPath(cwd) + ".manifest" }
 
-/** Atomic write: write to temp file then rename to replace, preventing truncated JSON from mid-write crash.
- *  rename is atomic on POSIX; on Windows with existing target, Node 24 uses MoveFileExW+REPLACE_EXISTING for atomic replace.
- *  Some older Windows filesystems may throw EPERM — retry once. */
+/** Path to the active slot's file */
+export function activePath(cwd) {
+  return slotPath(cwd, activeSlot(cwd))
+}
+
+/** Atomic write: write to temp file then rename to replace, preventing truncated JSON from mid-write crash. */
 function writeSessionFile(p, data) {
   mkdirSync(dirname(p), { recursive: true })
   const tmp = `${p}.tmp`
@@ -33,15 +73,11 @@ function writeSessionFile(p, data) {
   try {
     renameSync(tmp, p)
   } catch {
-    // Windows: rename may fail due to antivirus lock / network drive contention — delete target and retry
     try { unlinkSync(p) } catch {}
     try {
       renameSync(tmp, p)
-      // rename succeeded: clean up temp file
       try { unlinkSync(tmp) } catch {}
     } catch {
-      // rename still failed — fall back to direct write (non-atomic but data-preserving)
-      // p was deleted above; avoid losing both old and new data
       writeFileSync(p, readFileSync(tmp, "utf8"), "utf8")
     }
   }
@@ -49,86 +85,181 @@ function writeSessionFile(p, data) {
 
 // ========== slot management ==========
 
+/** Normalize slot metadata: old format is a raw timestamp number; new format is { ts, ... } object */
+function slotMetaTs(v) { return typeof v === "number" ? v : (v?.ts ?? 0) }
+
+function slotCmp(a, b) { return slotMetaTs(a[1]) - slotMetaTs(b[1]) }
+
+/** Detect a genuine user message (excludes system-reminder injected messages) */
+function isRealUserMsg(m) {
+  return m.role === "user" && typeof m.content === "string" && !m.content.startsWith("[System reminder:")
+}
+
+/** Extract slot metadata from history (shared by slotDigest and loadSlotMeta) */
+function extractSlotMeta(history, activeProvider, updatedAt, title = "") {
+  const userMsgs = history.filter(isRealUserMsg)
+  const first = userMsgs[0]?.content ?? ""
+  return {
+    messageCount: history.length,
+    turnCount: userMsgs.length,
+    firstMessage: first.slice(0, 80),
+    activeProvider: activeProvider ?? "",
+    updatedAt: updatedAt ?? Date.now(),
+    title,
+  }
+}
+
+/** Extract preview summary from session data for manifest storage (with current timestamp) */
+function slotDigest(data) {
+  const meta = extractSlotMeta(data.history ?? [], data.activeProvider, data.updatedAt, data.title ?? "")
+  return { ts: Date.now(), ...meta }
+}
+
 function loadManifest(cwd) {
   try {
     const p = manifestPath(cwd)
-    if (!existsSync(p)) return { slots: {} }
-    return JSON.parse(readFileSync(p, "utf8"))
-  } catch { return { slots: {} } }
+    if (!existsSync(p)) return { slots: {}, sessionId: null }
+    const m = JSON.parse(readFileSync(p, "utf8"))
+    if (!m.sessionId) m.sessionId = null
+    return m
+  } catch { return { slots: {}, sessionId: null } }
 }
 
 function saveManifest(cwd, m) {
+  m.sessionId = getSessionId()
   writeSessionFile(manifestPath(cwd), m)
 }
 
-/** Archive current session to a free slot — evict oldest if full; exclude specifies a slot that must not be evicted (switchToSlot target) */
-export function archiveCurrent(cwd, { exclude } = {}) {
-  const src = sessionPath(cwd)
-  if (!existsSync(src)) return
-  const m = loadManifest(cwd)
+/**
+ * Ensure an active slot exists in the manifest, migrating legacy data if needed.
+ * Called by activeSlot() — idempotent, safe to call repeatedly.
+ */
+/**
+ * Claim a slot for this process and set it as active. Idempotent.
+ * Preference order:
+ *  1. The current active slot, if it is unowned / ours / its owner is dead — reuse it.
+ *  2. Any slot that is unowned or owned by a dead process (reclaim).
+ *  3. A brand-new slot when all are owned by live processes.
+ * The owner is recorded in m.slotSessions so other processes (CLI ↔ VS Code) can
+ * see which slots are taken and avoid them.
+ */
+function ensureActive(cwd, m) {
+  const mySessionId = getSessionId()
+  if (!m.slotSessions) m.slotSessions = {}
+
+  // Already own the active slot — nothing to do.
+  if (m.active && m.slotSessions[m.active] === mySessionId) return
 
-  let slot
-  // Only count numeric-keyed slots, exclude legacy non-numeric keys like _currentName
-  const entries = Object.entries(m.slots).filter(([n]) => /^\d+$/.test(n))
-  if (entries.length < MAX_SLOTS) {
-    slot = 1
-    while (m.slots[slot]) slot++
-  } else {
-    const candidates = entries.filter(([n]) => Number(n) !== exclude)
-    slot = Number((candidates.length ? candidates : entries).sort((a, b) => a[1] - b[1])[0][0])
+  const isFree = (slot) => {
+    const owner = m.slotSessions[slot]
+    if (!owner || owner === mySessionId) return true
+    return !isProcessAlive(parseInt(owner.split('-')[0]))
   }
 
-  const dst = slotPath(cwd, slot)
-  // Copy (rename would lose current); use atomic write to prevent truncated JSON in archive from mid-crash
-  let data
-  try {
-    data = JSON.parse(readFileSync(src, "utf8"))
-  } catch {
-    // Session file corrupted, abandon archive; next save will overwrite
+  // 1. Prefer the current active slot if we can take it (preserves "resume where you left off").
+  if (m.active && m.slots[m.active] && isFree(m.active)) {
+    m.slotSessions[m.active] = mySessionId
+    saveManifest(cwd, m)
     return
   }
-  writeSessionFile(dst, data)
-  m.slots[slot] = Date.now()
-  delete m.slots._currentName
+
+  // 2. Otherwise claim the first slot that is free.
+  const allSlots = Object.keys(m.slots).filter(n => /^\d+$/.test(n)).map(Number).sort((a, b) => a - b)
+  for (const slot of allSlots) {
+    if (isFree(slot)) {
+      m.active = slot
+      m.slotSessions[slot] = mySessionId
+      saveManifest(cwd, m)
+      return
+    }
+  }
+
+  // 3. All slots owned by live processes — allocate a new one (no limit).
+  const newSlot = allSlots.length > 0 ? Math.max(...allSlots) + 1 : 1
+  m.active = newSlot
+  m.slotSessions[newSlot] = mySessionId
   saveManifest(cwd, m)
-  return slot
 }
 
-/** List all archive slots, newest first */
-export function listSlots(cwd) {
-  const m = loadManifest(cwd)
-  return Object.entries(m.slots)
-    .map(([n, ts]) => ({ slot: Number(n), timestamp: ts, date: new Date(ts).toLocaleString() }))
-    .sort((a, b) => b.timestamp - a.timestamp)
+/**
+ * Check if a process with given PID is still alive.
+ * Returns false if process doesn't exist or we can't determine.
+ */
+function isProcessAlive(pid) {
+  if (!pid || isNaN(pid)) return false
+  try {
+    // On Windows: tasklist /FI "PID eq <pid>" /NH
+    // On Unix: kill(pid, 0) or check /proc/<pid>
+    if (process.platform === 'win32') {
+      const output = execSync(`tasklist /FI "PID eq ${pid}" /NH`, { encoding: 'utf8', stdio: 'pipe' })
+      return output.includes(String(pid))
+    } else {
+      // Unix: try to send signal 0 (doesn't kill, just checks)
+      process.kill(pid, 0)
+      return true
+    }
+  } catch {
+    return false
+  }
 }
 
-/** Switch to a specific slot: archive current → copy slot file to current → return recovered data (null on failure) */
-export function switchToSlot(cwd, slot) {
+/** Return the active slot number for this process, claiming one if necessary */
+export function activeSlot(cwd) {
   const m = loadManifest(cwd)
-  if (!m.slots[slot]) return null
-
-  // Archive current (internally writes manifest; our `m` is stale after, must reload)
-  // When full, exclude target slot: otherwise oldest=target, archive would overwrite target then copy back, permanently losing the target session
-  archiveCurrent(cwd, { exclude: slot })
+  ensureActive(cwd, m)
+  return m.active
+}
 
-  // Slot file → current (copy+unlink, not rename: Windows rename on existing target throws EPERM)
-  const src = slotPath(cwd, slot)
-  const dst = sessionPath(cwd)
-  if (!existsSync(src)) return null
+/** Lazy-load slot metadata from slot file (for old-format manifest entries that lack metadata) */
+function loadSlotMeta(cwd, slot, v) {
+  if (typeof v === "object" && v !== null && "ts" in v) return v
+  const ts = typeof v === "number" ? v : 0
   try {
-    try { unlinkSync(dst) } catch { /* doesn't exist, that's fine */ }
-    copyFileSync(src, dst)
-    unlinkSync(src)
+    const p = slotPath(cwd, slot)
+    if (!existsSync(p)) return { ts }
+    const data = JSON.parse(readFileSync(p, "utf8"))
+    const history = data.history ?? []
+    const meta = extractSlotMeta(history, data.activeProvider, data.updatedAt ?? ts, data.title ?? "")
+    return { ts, ...meta }
   } catch {
-    // File operations failed (disk full / permissions / lock), abandon switch
-    return null
+    return { ts }
   }
+}
 
-  // Reload manifest (archiveCurrent modified it)
-  const m2 = loadManifest(cwd)
-  delete m2.slots[slot]
-  saveManifest(cwd, m2)
+/** List all slots, newest first. Includes isActive flag. */
+export function listSlots(cwd) {
+  const m = loadManifest(cwd)
+  const active = m.active ?? activeSlot(cwd)
+  return Object.entries(m.slots)
+    .filter(([n]) => /^\d+$/.test(n))
+    .map(([n, v]) => {
+      const meta = loadSlotMeta(cwd, Number(n), v)
+      return {
+        slot: Number(n),
+        isActive: Number(n) === active,
+        timestamp: meta.ts,
+        date: new Date(meta.ts).toLocaleString(),
+        messageCount: meta.messageCount ?? 0,
+        turnCount: meta.turnCount ?? 0,
+        firstMessage: meta.firstMessage ?? "",
+        activeProvider: meta.activeProvider ?? "",
+        updatedAt: meta.updatedAt ?? meta.ts,
+        updatedDate: new Date(meta.updatedAt ?? meta.ts).toLocaleString(),
+        title: meta.title ?? "",
+      }
+    })
+    .sort((a, b) => b.updatedAt - a.updatedAt)
+}
 
+/**
+ * Switch active slot. No file copying — just change the pointer in the manifest.
+ * Returns the loaded session data (null if slot doesn't exist).
+ */
+export function switchToSlot(cwd, slot) {
+  const m = loadManifest(cwd)
+  if (!m.slots[slot]) return null
+  m.active = slot
+  saveManifest(cwd, m)
   return loadSession(cwd)
 }
 
@@ -149,28 +280,47 @@ function isLegacyTransient(m) {
 
 // ========== core read/write ==========
 
-/** Save agent state and display lines to the session file (atomic write) */
+/** Save agent state and display lines to the active slot file (atomic write) */
 export function saveSession(agent, display) {
-  const history = agent.history.filter((m) => !m.transient && !isLegacyTransient(m))
+  // _fullHistory is written at the source via pushReal — no flush needed here.
+  // history        = FULL, never-compacted (human-readable; VS Code panel & CLI resume read this)
+  // contextHistory = machine context (possibly compacted) so CLI resume keeps the token savings
+  const history = (agent._fullHistory ?? agent.history).filter((m) => !m.transient && !isLegacyTransient(m))
+  const contextHistory = agent.history.filter((m) => !m.transient && !isLegacyTransient(m))
   const data = {
     version: 2,
     cwd: agent.cwd,
+    title: agent.title ?? "",
     activeProvider: agent.activeProvider ?? agent.provider?.name,
+    activeModel: agent.activeModel ?? null,
     updatedAt: Date.now(),
     history,
+    contextHistory,
     display: display ?? [],
     tasks: agent.tasks ?? [],
     planMode: agent.planMode ?? false,
     autoApprove: agent.autoApprove ?? false,
+    engineering: agent.config?.agent?.engineering ?? false,
+    engDesignToken: agent._engDesignToken ?? null,
     goal: agent.goal ?? null,
     advisor: agent.config?.advisor ?? null,
     pendingReminders: agent._pendingReminders ?? [],
     sessionStart: agent._sessionStart ?? null,
   }
-  writeSessionFile(sessionPath(agent.cwd), data)
+  const slot = activeSlot(agent.cwd)
+  writeSessionFile(slotPath(agent.cwd, slot), data)
+  // Update slot metadata in manifest
+  try {
+    const m = loadManifest(agent.cwd)
+    m.slots[slot] = slotDigest(data)
+    saveManifest(agent.cwd, m)
+  } catch (e) {
+    // Manifest update failure is non-fatal — data is safe, metadata will lazy-recover on next listSlots
+    console.error(`[session] manifest metadata update failed for slot ${slot}: ${e.message}`)
+  }
 }
 
-/** Load session data from disk; returns null if missing, corrupted, or version mismatch */
+/** Load session data from the active slot; returns null if missing, corrupted, or version mismatch */
 export function loadSession(cwd) {
   const tryLoad = (p) => {
     try {
@@ -189,34 +339,56 @@ export function loadSession(cwd) {
       return { _error: e }
     }
   }
-  const p = sessionPath(cwd)
+
+  // Try the active slot first (post-migration, legacy file may be stale)
+  const slot = activeSlot(cwd)
+  const p = slotPath(cwd, slot)
   let result = tryLoad(p)
+  if (result && !result._error) return result
   if (result?._error) {
-    // Main file corrupted — try the .tmp fallback from a failed atomic write
-    console.error(`[session] failed to load ${p}: ${result._error.message}. Trying .tmp fallback...`)
+    console.error(`[session] failed to load slot ${slot}: ${result._error.message}. Trying .tmp fallback...`)
     const tmpResult = tryLoad(`${p}.tmp`)
     if (tmpResult && !tmpResult._error) {
       console.error(`[session] recovered from .tmp fallback`)
-      result = tmpResult
-      result._recovered = true
-    } else {
-      console.error(`[session] .tmp fallback also failed — session lost. Backing up corrupted file as .corrupted.`)
-      try { renameSync(p, `${p}.corrupted`) } catch (e) { console.error(`[session] rename to .corrupted also failed: ${e.message}`) }
-      return null
+      tmpResult._recovered = true
+      return tmpResult
     }
+    console.error(`[session] .tmp fallback also failed — session lost.`)
+    try { renameSync(p, `${p}.corrupted`) } catch {}
+  }
+
+  // Fallback: try the legacy current file (pre-migration, or migration failed to clean up)
+  const legacy = sessionPath(cwd)
+  result = tryLoad(legacy)
+  if (result && !result._error) {
+    return result
+  }
+  if (result?._error) {
+    console.error(`[session] failed to load legacy ${legacy}: ${result._error.message}`)
+    try { renameSync(legacy, `${legacy}.corrupted`) } catch {}
   }
-  return result && !result._error ? result : null
+
+  return null
 }
 
 /** Apply loaded session data onto an agent object; returns true if provider was switched */
 export function applySession(agent, data) {
-  agent.history = data.history
+  // data.history is the FULL never-compacted record (human line); data.contextHistory is the
+  // (possibly compacted) machine line. Restore each line from its own source — the machine
+  // context keeps its compaction savings across resume. Legacy files without contextHistory
+  // fall back to seeding the machine line from the full history (it re-compacts when needed).
+  const full = Array.isArray(data.history) ? data.history : []
+  const machine = Array.isArray(data.contextHistory) ? data.contextHistory : full
+  agent._fullHistory = [...full]
+  agent.history = [...machine]
+  agent.title = data.title ?? ""
   agent.tasks = data.tasks ?? []
   agent.planMode = data.planMode ?? false
   agent.autoApprove = data.autoApprove ?? false
   agent.goal = data.goal ?? null
   agent._pendingReminders = data.pendingReminders ?? []
   agent._sessionStart = data.sessionStart ?? null
+  agent._engDesignToken = data.engDesignToken ?? null
   if (data.advisor) {
     agent.config.advisor = { ...data.advisor }
   }
@@ -229,19 +401,44 @@ export function applySession(agent, data) {
     if (p) {
       agent.provider = { ...p }
       agent.activeProvider = p.name
+      agent.activeModel = data.activeModel ?? null
+      if (agent.activeModel) agent.provider.model = agent.activeModel
       return true
     }
+  } else if (data.activeModel != null) {
+    // Same provider, different model
+    agent.activeModel = data.activeModel
+    if (agent.activeModel && agent.provider) agent.provider.model = agent.activeModel
+  } else if (data.activeProvider && data.activeProvider === agent.activeProvider) {
+    // Same provider, session has no activeModel → clear stale override
+    agent.activeModel = null
+    if (agent.provider) {
+      const p = agent.providers?.find((pr) => pr.name === agent.activeProvider)
+      if (p) agent.provider.model = p.model
+    }
   }
   return false
 }
 
-/** Archive current session and reset the session file to empty state */
-export function clearSession(cwd) {
-  try {
-    archiveCurrent(cwd)
-    const p = sessionPath(cwd)
-    writeSessionFile(p, { version: 2, cwd, history: [], tasks: [], display: [], goal: null, autoApprove: false, advisor: null, pendingReminders: [], sessionStart: null })
-  } catch {
-    // Can't clear, oh well — next save will overwrite
-  }
+/**
+ * Create a new session slot: allocate a free slot number,
+ * write an empty session, and mark it as the active slot.
+ * No limit on the number of sessions.
+ */
+export function newSession(cwd) {
+  const m = loadManifest(cwd)
+  // Ensure active is set (migrate if needed)
+  if (!m.active) ensureActive(cwd, m)
+
+  // Find next available slot number
+  let slot = 1
+  while (m.slots[slot]) slot++
+
+  // Write empty session
+  const data = { version: 2, cwd, title: "", updatedAt: Date.now(), history: [], tasks: [], display: [], goal: null, autoApprove: false, advisor: null, pendingReminders: [], sessionStart: null }
+  writeSessionFile(slotPath(cwd, slot), data)
+  m.slots[slot] = slotDigest(data)
+  m.active = slot
+  saveManifest(cwd, m)
+  return slot
 }

package/src/skills.mjs

@@ -11,6 +11,7 @@
 
 import { readFile, readdir, stat } from "node:fs/promises"
 import { join } from "node:path"
+import { homedir } from "node:os"
 
 /** Valid skill name pattern (alphanumeric + hyphens/underscores) */
 const NAME_RE = /^[a-zA-Z0-9_-]+$/
@@ -42,13 +43,12 @@ async function tryReadSkill(dir, name, filePath) {
 }
 
 /**
- * Scan .thincoder/skills/ directory, return skill list.
+ * Scan a single skills directory, return skill list.
  * Supports flat .md files and subdirectories with SKILL.md inside.
  * Each skill: { name, path, description } — name derived from filename or directory.
  * Returns empty array if directory is missing or empty.
  */
-export async function loadSkills(cwd) {
-  const dir = join(cwd, ".thincoder", "skills")
+async function loadSkillsFromDir(dir) {
   let entries
   try {
     entries = await readdir(dir, { withFileTypes: true })
@@ -79,6 +79,31 @@ export async function loadSkills(cwd) {
   return skills
 }
 
+/**
+ * Scan both project-level and user-level skills directories.
+ * Project-level skills (cwd/.thincoder/skills/) take priority over user-level (~/.thincoder/skills/).
+ * Returns merged skill list with project-level skills first.
+ */
+export async function loadSkills(cwd) {
+  const projectDir = join(cwd, ".thincoder", "skills")
+  const userDir = join(homedir(), ".thincoder", "skills")
+  
+  // Load project-level skills first (higher priority)
+  const projectSkills = await loadSkillsFromDir(projectDir)
+  const added = new Set(projectSkills.map(s => s.name))
+  
+  // Load user-level skills, skipping duplicates
+  const userSkills = await loadSkillsFromDir(userDir)
+  for (const skill of userSkills) {
+    if (!added.has(skill.name)) {
+      projectSkills.push(skill)
+      added.add(skill.name)
+    }
+  }
+  
+  return projectSkills
+}
+
 /**
  * Generate skill listing text for system prompt injection.
  * At most 3 (small footprint); overflow marked "... and N more".
@@ -94,23 +119,31 @@ export function formatSkillListing(skills) {
 
 /**
  * Read the full content of a specific skill file.
- * Tries subdirectory format (name/SKILL.md) first, then flat format (name.md).
+ * Tries project-level directory first, then user-level directory.
+ * For each directory, tries subdirectory format (name/SKILL.md) first, then flat format (name.md).
  * Returns text, or null if not found.
  */
 export async function readSkill(cwd, name) {
   if (!NAME_RE.test(name)) return null
 
-  // Try subdirectory format: name/SKILL.md
-  try {
-    const p = join(cwd, ".thincoder", "skills", name, "SKILL.md")
-    return await readFile(p, "utf8")
-  } catch { /* not found, try flat */ }
+  const dirs = [
+    join(cwd, ".thincoder", "skills"),
+    join(homedir(), ".thincoder", "skills")
+  ]
 
-  // Fallback to flat format: name.md
-  try {
-    const p = join(cwd, ".thincoder", "skills", `${name}.md`)
-    return await readFile(p, "utf8")
-  } catch {
-    return null
+  for (const baseDir of dirs) {
+    // Try subdirectory format: name/SKILL.md
+    try {
+      const p = join(baseDir, name, "SKILL.md")
+      return await readFile(p, "utf8")
+    } catch { /* not found, try flat */ }
+
+    // Fallback to flat format: name.md
+    try {
+      const p = join(baseDir, `${name}.md`)
+      return await readFile(p, "utf8")
+    } catch { /* not found, try next directory */ }
   }
+  
+  return null
 }

package/src/tools/apply_patch.md

@@ -8,4 +8,4 @@ Notes:
 - Hunks are located by their context/removed lines, not line numbers — but the context must match the file EXACTLY. Read the files first and generate the patch from actual content
 - If a hunk's context matches multiple locations it is rejected — add more surrounding context lines
 - Deleting files is not supported — use the delete tool
-- For single-file small edits, edit is simpler; for full rewrites, write is simpler
+- For single-file edits, edit is simpler; for full rewrites, write is simpler

package/src/tools/checklist.mjs

@@ -31,14 +31,15 @@ function parse(filePath) {
     const status = raw === "x" ? "done" : raw === "~" ? "in_progress" : "pending"
     const text = m[3].trim()
 
-    // Extract explicit ID if present (e.g. "T1:", "T1.1:")
-    const idMatch = text.match(/^(T[\d.]+):/)
+    // Extract explicit ID if present (e.g. "T1:", "T1.1:") — strip it from the text
+    // so write() doesn't re-prepend it (round-trip would otherwise accumulate "T1: T1: ...")
+    const idMatch = text.match(/^(T[\d.]+):\s*/)
     const node = {
       id: idMatch ? idMatch[1] : null,
       index: flatIdx,
       depth,
       status,
-      text,
+      text: idMatch ? text.slice(idMatch[0].length) : text,
       children: [],
     }