Skills engine v0.1 + multi-channel infrastructure (#307)

* refactor: multi-channel infrastructure with explicit channel/is_group tracking

- Add channels[] array and findChannel() routing in index.ts, replacing
  hardcoded whatsapp.* calls with channel-agnostic callbacks
- Add channel TEXT and is_group INTEGER columns to chats table with
  COALESCE upsert to protect existing values from null overwrites
- is_group defaults to 0 (safe: unknown chats excluded from groups)
- WhatsApp passes explicit channel='whatsapp' and isGroup to onChatMetadata
- getAvailableGroups filters on is_group instead of JID pattern matching
- findChannel logs warnings instead of silently dropping unroutable JIDs
- Migration backfills channel/is_group from JID patterns for existing DBs

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat: skills engine v0.1 — deterministic skill packages with rerere resolution

Three-way merge engine for applying skill packages on top of a core
codebase. Skills declare which files they add/modify, and the engine
uses git merge-file for conflict detection with git rerere for
automatic resolution of previously-seen conflicts.

Key components:
- apply: three-way merge with backup/rollback safety net
- replay: clean-slate replay for uninstall and rebase
- update: core version updates with deletion detection
- rebase: bake applied skills into base (one-way)
- manifest: validation with path traversal protection
- resolution-cache: pre-computed rerere resolutions
- structured: npm deps, env vars, docker-compose merging
- CI: per-skill test matrix with conflict detection

151 unit tests covering merge, rerere, backup, replay, uninstall,
update, rebase, structured ops, and edge cases.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat: add Discord and Telegram skill packages

Skill packages for adding Discord and Telegram channels to NanoClaw.
Each package includes:
- Channel implementation (add/src/channels/)
- Three-way merge targets for index.ts, config.ts, routing.test.ts
- Intent docs explaining merge invariants
- Standalone integration tests
- manifest.yaml with dependency/conflict declarations

Applied via: npx tsx scripts/apply-skill.ts .claude/skills/add-discord
These are inert until applied — no runtime impact.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* remove unused docs (skills-system-status, implementation-guide)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

skills-engine/lock.ts

@@ -0,0 +1,102 @@
+import fs from 'fs';
+import path from 'path';
+
+import { LOCK_FILE } from './constants.js';
+
+const STALE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+
+interface LockInfo {
+  pid: number;
+  timestamp: number;
+}
+
+function getLockPath(): string {
+  return path.join(process.cwd(), LOCK_FILE);
+}
+
+function isStale(lock: LockInfo): boolean {
+  return Date.now() - lock.timestamp > STALE_TIMEOUT_MS;
+}
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function acquireLock(): () => void {
+  const lockPath = getLockPath();
+  fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+
+  const lockInfo: LockInfo = { pid: process.pid, timestamp: Date.now() };
+
+  try {
+    // Atomic creation — fails if file already exists
+    fs.writeFileSync(lockPath, JSON.stringify(lockInfo), { flag: 'wx' });
+    return () => releaseLock();
+  } catch {
+    // Lock file exists — check if it's stale or from a dead process
+    try {
+      const existing: LockInfo = JSON.parse(
+        fs.readFileSync(lockPath, 'utf-8'),
+      );
+      if (!isStale(existing) && isProcessAlive(existing.pid)) {
+        throw new Error(
+          `Operation in progress (pid ${existing.pid}, started ${new Date(existing.timestamp).toISOString()}). If this is stale, delete ${LOCK_FILE}`,
+        );
+      }
+      // Stale or dead process — overwrite
+    } catch (err) {
+      if (
+        err instanceof Error &&
+        err.message.startsWith('Operation in progress')
+      ) {
+        throw err;
+      }
+      // Corrupt or unreadable — overwrite
+    }
+
+    try { fs.unlinkSync(lockPath); } catch { /* already gone */ }
+    try {
+      fs.writeFileSync(lockPath, JSON.stringify(lockInfo), { flag: 'wx' });
+    } catch {
+      throw new Error('Lock contention: another process acquired the lock. Retry.');
+    }
+    return () => releaseLock();
+  }
+}
+
+export function releaseLock(): void {
+  const lockPath = getLockPath();
+  if (fs.existsSync(lockPath)) {
+    try {
+      const lock: LockInfo = JSON.parse(fs.readFileSync(lockPath, 'utf-8'));
+      // Only release our own lock
+      if (lock.pid === process.pid) {
+        fs.unlinkSync(lockPath);
+      }
+    } catch {
+      // Corrupt or missing — safe to remove
+      try {
+        fs.unlinkSync(lockPath);
+      } catch {
+        // Already gone
+      }
+    }
+  }
+}
+
+export function isLocked(): boolean {
+  const lockPath = getLockPath();
+  if (!fs.existsSync(lockPath)) return false;
+
+  try {
+    const lock: LockInfo = JSON.parse(fs.readFileSync(lockPath, 'utf-8'));
+    return !isStale(lock) && isProcessAlive(lock.pid);
+  } catch {
+    return false;
+  }
+}