viepilot 2.47.0 → 2.48.0

package/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.48.0] - 2026-05-17
+
+### Added
+- **ENH-082** `vp-intake` skill — import and triage tickets from external sources (Phase 123):
+  - **Excel/Microsoft 365 Online** adapter via Microsoft Graph API (client credentials OAuth 2.0)
+  - **Google Sheets** adapter via Sheets API v4 (Service Account OAuth 2.0)
+  - **CSV/TSV local file** adapter with configurable column mapping
+  - **Heuristic classifier** auto-assigns `BUG` / `ENH` / `UNCLEAR` per ticket; supports
+    English and Vietnamese keywords; BUG takes precedence over ENH
+  - **AskUserQuestion triage**: multi-select accept/decline per ticket (paginated at 4/page);
+    UNCLEAR tickets get a 3-choice prompt (Accept as BUG / Accept as ENH / Decline)
+  - **Reason collection**: declined tickets prompt user for decline reason via AUQ single-select
+  - **Auto-create request files**: accepted tickets generate `.viepilot/requests/BUG-N.md` or
+    `ENH-N.md` with source channel attribution
+  - **Write-back engine**: updates `VP_Status`, `VP_Comment`, `VP_RequestID` columns in source
+    (CSV overwrite, Google Sheets batchUpdate); write-back failure is non-fatal
+  - **TRIAGE session report**: `.viepilot/intake/TRIAGE-{timestamp}.md` generated after every
+    session with accepted/declined/unclear summary tables
+  - **`channels.json` config**: `.viepilot/intake/channels.json` supports multiple concurrent
+    channels; validated schema with required field checks
+  - **`vp-tools intake-init`** command: scaffolds `.viepilot/intake/channels.json` (3 example
+    channels), creates `.viepilot/.credentials/` (gitignored) — idempotent
+
 ## [2.47.0] - 2026-05-06
 
 ### Added

package/bin/vp-tools.cjs

@@ -1288,6 +1288,21 @@ ${colors.cyan}Examples:${colors.reset}
     process.exit(0);
   },
 
+  /**
+   * Initialize .viepilot/intake/ directory with channels.json scaffold (ENH-082)
+   */
+  'intake-init': (_args) => {
+    const { initIntakeDir } = require('../lib/intake/channels.cjs');
+    const projectCheck = validators.requireProjectRoot();
+    validateArgs([projectCheck]);
+    const projectRoot = projectCheck.value;
+    const { channelsPath, credentialsDir } = initIntakeDir(projectRoot);
+    console.log(formatSuccess('intake/ initialized'));
+    console.log(`  channels.json : ${channelsPath}`);
+    console.log(`  credentials   : ${credentialsDir}`);
+    console.log('\nEdit .viepilot/intake/channels.json to configure your ticket channels.');
+  },
+
   /**
    * Help
    */

package/lib/intake/adapters/csv.cjs

@@ -0,0 +1,81 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+function parseCsvLine(line, delimiter) {
+  const result = [];
+  let current = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (ch === '"') {
+      if (inQuotes && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else {
+        inQuotes = !inQuotes;
+      }
+    } else if (ch === delimiter && !inQuotes) {
+      result.push(current.trim());
+      current = '';
+    } else {
+      current += ch;
+    }
+  }
+  result.push(current.trim());
+  return result;
+}
+
+function applyColumnMap(headers, row, columnMap) {
+  const headerIndex = {};
+  headers.forEach((h, i) => { headerIndex[h.trim()] = i; });
+
+  const get = (fieldName) => {
+    const mapped = columnMap[fieldName];
+    if (!mapped) return '';
+    const idx = headerIndex[mapped];
+    return idx !== undefined ? (row[idx] || '') : '';
+  };
+
+  return {
+    id:          get('id'),
+    title:       get('title'),
+    description: get('description'),
+    reporter:    get('reporter'),
+    date:        get('date'),
+    status:      get('status'),
+  };
+}
+
+async function readCsv(channel, projectRoot) {
+  const filePath = path.resolve(projectRoot || process.cwd(), channel.path);
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`CSV file not found: ${filePath}`);
+  }
+
+  const ext = path.extname(filePath).toLowerCase();
+  const delimiter = ext === '.tsv' ? '\t' : ',';
+
+  const content = fs.readFileSync(filePath, 'utf8');
+  const lines = content.split(/\r?\n/).filter((l) => l.trim() !== '');
+
+  if (lines.length === 0) return [];
+
+  const headers = parseCsvLine(lines[0], delimiter);
+  const tickets = [];
+
+  for (let i = 1; i < lines.length; i++) {
+    const row = parseCsvLine(lines[i], delimiter);
+    const ticket = applyColumnMap(headers, row, channel.column_map);
+    if (!ticket.title && !ticket.description) continue;
+    ticket._source_row = i;
+    ticket._channel_id = channel.id;
+    tickets.push(ticket);
+  }
+
+  return tickets;
+}
+
+module.exports = { readCsv };

package/lib/intake/adapters/excel-m365.cjs

@@ -0,0 +1,162 @@
+'use strict';
+
+const fs    = require('fs');
+const path  = require('path');
+const https = require('https');
+
+const CREDENTIALS_REL = path.join('.viepilot', '.credentials', 'm365-credentials.json');
+
+const SETUP_GUIDE = `
+Microsoft 365 / Excel setup:
+  1. Go to portal.azure.com → Azure Active Directory → App Registrations → New
+  2. Add API permission: Microsoft Graph → Files.Read.All (Application) → Grant admin consent
+  3. Certificates & Secrets → New client secret → copy value immediately
+  4. Save credentials to: .viepilot/.credentials/m365-credentials.json
+     { "tenant_id": "...", "client_id": "...", "client_secret": "..." }
+  5. In channels.json, set "workbook_id" to the file's drive item ID
+     (visible in the file's URL on SharePoint/OneDrive)
+  6. Re-run vp-intake
+`;
+
+class AuthRequiredError extends Error {
+  constructor(msg) {
+    super(msg);
+    this.name = 'AuthRequiredError';
+  }
+}
+
+let _tokenCache = null;
+
+function colLetterToIndex(letter) {
+  let index = 0;
+  for (const ch of letter.toUpperCase()) {
+    index = index * 26 + ch.charCodeAt(0) - 64;
+  }
+  return index - 1;
+}
+
+function httpsPost(url, body, headers) {
+  return new Promise((resolve, reject) => {
+    const payload = typeof body === 'string' ? body : JSON.stringify(body);
+    const urlObj = new URL(url);
+    const req = https.request({
+      hostname: urlObj.hostname,
+      path: urlObj.pathname + urlObj.search,
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'Content-Length': Buffer.byteLength(payload), ...headers },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => { try { resolve(JSON.parse(data)); } catch { resolve(data); } });
+    });
+    req.on('error', reject);
+    req.write(payload);
+    req.end();
+  });
+}
+
+function httpsGet(url, headers) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const req = https.request({
+      hostname: urlObj.hostname,
+      path: urlObj.pathname + urlObj.search,
+      method: 'GET',
+      headers: { Accept: 'application/json', ...headers },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => { try { resolve(JSON.parse(data)); } catch { resolve(data); } });
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+function encodeFormData(obj) {
+  return Object.entries(obj)
+    .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+    .join('&');
+}
+
+async function getAccessToken(creds) {
+  const now = Math.floor(Date.now() / 1000);
+  if (_tokenCache && _tokenCache.expires_at > now + 60) {
+    return _tokenCache.access_token;
+  }
+
+  const url = `https://login.microsoftonline.com/${creds.tenant_id}/oauth2/v2.0/token`;
+  const res = await httpsPost(url, encodeFormData({
+    grant_type: 'client_credentials',
+    client_id: creds.client_id,
+    client_secret: creds.client_secret,
+    scope: 'https://graph.microsoft.com/.default',
+  }));
+
+  if (!res.access_token) {
+    throw new Error(`M365 auth failed: ${JSON.stringify(res)}`);
+  }
+
+  _tokenCache = { access_token: res.access_token, expires_at: now + (res.expires_in || 3600) };
+  return res.access_token;
+}
+
+async function readExcelM365(channel, projectRoot) {
+  const root = projectRoot || process.cwd();
+  const credPath = path.join(root, CREDENTIALS_REL);
+
+  if (!fs.existsSync(credPath)) {
+    throw new AuthRequiredError(SETUP_GUIDE);
+  }
+
+  let creds;
+  try {
+    creds = JSON.parse(fs.readFileSync(credPath, 'utf8'));
+  } catch (e) {
+    throw new Error(`Failed to parse m365-credentials.json: ${e.message}`);
+  }
+
+  if (!creds.tenant_id || !creds.client_id || !creds.client_secret) {
+    throw new AuthRequiredError(`m365-credentials.json is incomplete.${SETUP_GUIDE}`);
+  }
+
+  const token = await getAccessToken(creds);
+  const sheetName = encodeURIComponent(channel.sheet_name || 'Sheet1');
+  const url = `https://graph.microsoft.com/v1.0/me/drive/items/${channel.workbook_id}/workbook/worksheets/${sheetName}/usedRange`;
+  const response = await httpsGet(url, { Authorization: `Bearer ${token}` });
+
+  if (!response.values || response.values.length === 0) return [];
+
+  const colMap = channel.column_map;
+  const tickets = [];
+
+  for (let i = 1; i < response.values.length; i++) {
+    const row = response.values[i];
+    const get = (field) => {
+      const col = colMap[field];
+      if (!col) return '';
+      const idx = colLetterToIndex(col);
+      return row[idx] !== undefined ? String(row[idx]) : '';
+    };
+
+    const ticket = {
+      id:          get('id'),
+      title:       get('title'),
+      description: get('description'),
+      reporter:    get('reporter'),
+      date:        get('date'),
+      status:      get('status'),
+      _source_row: i,
+      _channel_id: channel.id,
+    };
+
+    if (!ticket.title && !ticket.description) continue;
+    tickets.push(ticket);
+  }
+
+  return tickets;
+}
+
+function clearTokenCache() { _tokenCache = null; }
+
+module.exports = { readExcelM365, AuthRequiredError, clearTokenCache };

package/lib/intake/adapters/google-sheets.cjs

@@ -0,0 +1,161 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+const https = require('https');
+
+const CREDENTIALS_REL = path.join('.viepilot', '.credentials', 'google-service-account.json');
+
+const SETUP_GUIDE = `
+Google Sheets setup:
+  1. Go to console.cloud.google.com → Create project → Enable Sheets API
+  2. IAM → Service Accounts → Create → Download JSON key
+  3. Save key to: .viepilot/.credentials/google-service-account.json
+  4. Share your Google Sheet with the service account email (viewer access)
+  5. Re-run vp-intake
+`;
+
+class AuthRequiredError extends Error {
+  constructor(msg) {
+    super(msg);
+    this.name = 'AuthRequiredError';
+  }
+}
+
+function colLetterToIndex(letter) {
+  let index = 0;
+  for (const ch of letter.toUpperCase()) {
+    index = index * 26 + ch.charCodeAt(0) - 64;
+  }
+  return index - 1;
+}
+
+function httpsPost(url, body, headers) {
+  return new Promise((resolve, reject) => {
+    const payload = typeof body === 'string' ? body : JSON.stringify(body);
+    const urlObj = new URL(url);
+    const req = https.request({
+      hostname: urlObj.hostname,
+      path: urlObj.pathname + urlObj.search,
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'Content-Length': Buffer.byteLength(payload), ...headers },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); } catch { resolve(data); }
+      });
+    });
+    req.on('error', reject);
+    req.write(payload);
+    req.end();
+  });
+}
+
+function httpsGet(url, headers) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const req = https.request({
+      hostname: urlObj.hostname,
+      path: urlObj.pathname + urlObj.search,
+      method: 'GET',
+      headers: { Accept: 'application/json', ...headers },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); } catch { resolve(data); }
+      });
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+function encodeFormData(obj) {
+  return Object.entries(obj)
+    .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+    .join('&');
+}
+
+async function getAccessToken(keyJson, projectRoot) {
+  const now = Math.floor(Date.now() / 1000);
+  const header = Buffer.from(JSON.stringify({ alg: 'RS256', typ: 'JWT' })).toString('base64url');
+  const payload = Buffer.from(JSON.stringify({
+    iss: keyJson.client_email,
+    scope: 'https://www.googleapis.com/auth/spreadsheets.readonly',
+    aud: 'https://oauth2.googleapis.com/token',
+    exp: now + 3600,
+    iat: now,
+  })).toString('base64url');
+
+  const crypto = require('crypto');
+  const sign = crypto.createSign('RSA-SHA256');
+  sign.update(`${header}.${payload}`);
+  const signature = sign.sign(keyJson.private_key, 'base64url');
+  const jwt = `${header}.${payload}.${signature}`;
+
+  const tokenRes = await httpsPost(
+    'https://oauth2.googleapis.com/token',
+    encodeFormData({ grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer', assertion: jwt }),
+  );
+  if (!tokenRes.access_token) {
+    throw new Error(`Google auth failed: ${JSON.stringify(tokenRes)}`);
+  }
+  return tokenRes.access_token;
+}
+
+async function readGoogleSheet(channel, projectRoot) {
+  const root = projectRoot || process.cwd();
+  const credPath = path.join(root, CREDENTIALS_REL);
+
+  if (!fs.existsSync(credPath)) {
+    throw new AuthRequiredError(SETUP_GUIDE);
+  }
+
+  let keyJson;
+  try {
+    keyJson = JSON.parse(fs.readFileSync(credPath, 'utf8'));
+  } catch (e) {
+    throw new Error(`Failed to parse google-service-account.json: ${e.message}`);
+  }
+
+  const accessToken = await getAccessToken(keyJson, root);
+  const sheetName = encodeURIComponent(channel.sheet_name || 'Sheet1');
+  const url = `https://sheets.googleapis.com/v4/spreadsheets/${channel.spreadsheet_id}/values/${sheetName}!A:Z`;
+  const response = await httpsGet(url, { Authorization: `Bearer ${accessToken}` });
+
+  if (!response.values || response.values.length === 0) return [];
+
+  const colMap = channel.column_map;
+  const tickets = [];
+
+  for (let i = 1; i < response.values.length; i++) {
+    const row = response.values[i];
+    const get = (field) => {
+      const col = colMap[field];
+      if (!col) return '';
+      const idx = colLetterToIndex(col);
+      return row[idx] || '';
+    };
+
+    const ticket = {
+      id:          get('id'),
+      title:       get('title'),
+      description: get('description'),
+      reporter:    get('reporter'),
+      date:        get('date'),
+      status:      get('status'),
+      _source_row: i,
+      _channel_id: channel.id,
+    };
+
+    if (!ticket.title && !ticket.description) continue;
+    tickets.push(ticket);
+  }
+
+  return tickets;
+}
+
+module.exports = { readGoogleSheet, AuthRequiredError };

package/lib/intake/channels.cjs

@@ -0,0 +1,139 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const CHANNELS_REL = path.join('.viepilot', 'intake', 'channels.json');
+
+const REQUIRED_CHANNEL_FIELDS = ['id', 'type', 'name'];
+const REQUIRED_COLUMN_MAP_FIELDS = ['title', 'description'];
+const VALID_TYPES = ['csv', 'google_sheets', 'excel_m365'];
+
+const CHANNELS_SCAFFOLD = {
+  channels: [
+    {
+      id: 'csv-example',
+      type: 'csv',
+      name: 'Local CSV Export',
+      path: './reports/tickets.csv',
+      column_map: {
+        id: 'ticket_id',
+        title: 'summary',
+        description: 'details',
+        reporter: 'author',
+        date: 'created_at',
+        status: 'status',
+      },
+    },
+    {
+      id: 'gsheet-example',
+      type: 'google_sheets',
+      name: 'Google Sheet Tickets',
+      spreadsheet_id: 'REPLACE_WITH_SPREADSHEET_ID',
+      sheet_name: 'Sheet1',
+      column_map: {
+        id: 'A',
+        title: 'B',
+        description: 'C',
+        reporter: 'D',
+        date: 'E',
+        status: 'F',
+      },
+    },
+    {
+      id: 'm365-example',
+      type: 'excel_m365',
+      name: 'M365 Excel Tickets',
+      workbook_id: 'REPLACE_WITH_WORKBOOK_ID',
+      sheet_name: 'Tickets',
+      column_map: {
+        id: 'A',
+        title: 'B',
+        description: 'C',
+        reporter: 'D',
+        date: 'E',
+        status: 'F',
+      },
+    },
+  ],
+};
+
+function loadChannels(projectRoot) {
+  const channelsPath = path.join(projectRoot, CHANNELS_REL);
+  if (!fs.existsSync(channelsPath)) {
+    return { channels: [] };
+  }
+  try {
+    return JSON.parse(fs.readFileSync(channelsPath, 'utf8'));
+  } catch (e) {
+    throw new Error(`Failed to parse channels.json: ${e.message}`);
+  }
+}
+
+function validateChannel(channel) {
+  for (const field of REQUIRED_CHANNEL_FIELDS) {
+    if (!channel[field]) {
+      throw new Error(`Channel missing required field: "${field}"`);
+    }
+  }
+  if (!VALID_TYPES.includes(channel.type)) {
+    throw new Error(`Invalid channel type "${channel.type}". Must be one of: ${VALID_TYPES.join(', ')}`);
+  }
+  if (!channel.column_map) {
+    throw new Error(`Channel "${channel.id}" missing "column_map"`);
+  }
+  for (const field of REQUIRED_COLUMN_MAP_FIELDS) {
+    if (!channel.column_map[field]) {
+      throw new Error(`Channel "${channel.id}" column_map missing required field: "${field}"`);
+    }
+  }
+  if (channel.type === 'csv' && !channel.path) {
+    throw new Error(`CSV channel "${channel.id}" must have a "path" field`);
+  }
+  if (channel.type === 'google_sheets' && !channel.spreadsheet_id) {
+    throw new Error(`Google Sheets channel "${channel.id}" must have a "spreadsheet_id" field`);
+  }
+  if (channel.type === 'excel_m365' && !channel.workbook_id) {
+    throw new Error(`Excel/M365 channel "${channel.id}" must have a "workbook_id" field`);
+  }
+  return true;
+}
+
+function getChannelById(id, channels) {
+  return (channels || []).find((c) => c.id === id) || null;
+}
+
+function initIntakeDir(projectRoot) {
+  const intakeDir = path.join(projectRoot, '.viepilot', 'intake');
+  const channelsPath = path.join(intakeDir, 'channels.json');
+  const credentialsDir = path.join(projectRoot, '.viepilot', '.credentials');
+  const gitkeepPath = path.join(credentialsDir, '.gitkeep');
+  const gitignorePath = path.join(projectRoot, '.gitignore');
+
+  if (!fs.existsSync(intakeDir)) {
+    fs.mkdirSync(intakeDir, { recursive: true });
+  }
+
+  if (!fs.existsSync(channelsPath)) {
+    fs.writeFileSync(channelsPath, JSON.stringify(CHANNELS_SCAFFOLD, null, 2) + '\n', 'utf8');
+  }
+
+  if (!fs.existsSync(credentialsDir)) {
+    fs.mkdirSync(credentialsDir, { recursive: true });
+  }
+  if (!fs.existsSync(gitkeepPath)) {
+    fs.writeFileSync(gitkeepPath, '', 'utf8');
+  }
+
+  if (fs.existsSync(gitignorePath)) {
+    const existing = fs.readFileSync(gitignorePath, 'utf8');
+    const entry = '.viepilot/.credentials/';
+    if (!existing.includes(entry)) {
+      fs.appendFileSync(gitignorePath, `\n# ViePilot OAuth credentials (ENH-082)\n${entry}\n`, 'utf8');
+    }
+  }
+
+  return { intakeDir, channelsPath, credentialsDir };
+}
+
+module.exports = { loadChannels, validateChannel, getChannelById, initIntakeDir, CHANNELS_SCAFFOLD };

package/lib/intake/classifier.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+const BUG_KEYWORDS = [
+  'bug', 'error', 'fail', 'crash', 'broken', 'fix', 'exception', 'regression',
+  'wrong', 'incorrect', 'unexpected', 'null', 'undefined', '500', '404',
+  // Vietnamese
+  'lỗi', 'sự cố', 'không hoạt động', 'hỏng', 'sai', 'vá lỗi', 'bị lỗi',
+];
+
+const ENH_KEYWORDS = [
+  'add', 'new', 'feature', 'improve', 'enhance', 'update', 'upgrade',
+  'support', 'request', 'implement', 'integrate', 'extend',
+  // Vietnamese
+  'thêm', 'nâng cấp', 'tính năng', 'cải tiến', 'tích hợp', 'mở rộng',
+  'yêu cầu', 'bổ sung', 'phát triển',
+];
+
+function classifyTicket(ticket) {
+  const text = `${ticket.title || ''} ${ticket.description || ''}`.toLowerCase();
+
+  for (const kw of BUG_KEYWORDS) {
+    if (text.includes(kw)) return 'BUG';
+  }
+  for (const kw of ENH_KEYWORDS) {
+    if (text.includes(kw)) return 'ENH';
+  }
+  return 'UNCLEAR';
+}
+
+module.exports = { classifyTicket };

package/lib/intake/report.cjs

@@ -0,0 +1,88 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+function truncate(str, max) {
+  if (!str) return '';
+  return str.length > max ? str.slice(0, max - 1) + '…' : str;
+}
+
+function generateTriageReport(channel, triageResult, projectRoot) {
+  const root = projectRoot || process.cwd();
+  const now = new Date();
+  const ts = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const tsDisplay = now.toISOString();
+
+  const accepted = triageResult.accepted || [];
+  const declined = triageResult.declined || [];
+  const unclear  = triageResult.unclear  || [];
+  const total = accepted.length + declined.length + unclear.length;
+
+  const acceptedRows = accepted.map(({ ticket, request_id }) =>
+    `| ${ticket.id || ticket._source_row} | ${truncate(ticket.title, 50)} | ${ticket._classified || '?'} | ${request_id} |`
+  ).join('\n') || '| — | — | — | — |';
+
+  const declinedRows = declined.map(({ ticket, reason }) =>
+    `| ${ticket.id || ticket._source_row} | ${truncate(ticket.title, 50)} | ${truncate(reason, 60)} |`
+  ).join('\n') || '| — | — | — |';
+
+  const unclearRows = unclear.map(({ ticket }) =>
+    `| ${ticket.id || ticket._source_row} | ${truncate(ticket.title, 50)} |`
+  ).join('\n') || '| — | — |';
+
+  const pkgVersion = (() => {
+    try {
+      return require(path.join(root, 'package.json')).version;
+    } catch {
+      return 'unknown';
+    }
+  })();
+
+  const report = `# Triage Report — ${channel.name}
+
+**Session**: ${tsDisplay}
+**Channel**: ${channel.name} (${channel.type})
+**Total Tickets**: ${total}
+
+## Summary
+
+| Decision | Count |
+|----------|-------|
+| Accepted | ${accepted.length} |
+| Declined | ${declined.length} |
+| Unclear  | ${unclear.length} |
+
+## Accepted Tickets
+
+| Source ID | Title | Type | Request Created |
+|-----------|-------|------|-----------------|
+${acceptedRows}
+
+## Declined Tickets
+
+| Source ID | Title | Reason |
+|-----------|-------|--------|
+${declinedRows}
+
+## Unclear Tickets (not actioned)
+
+| Source ID | Title |
+|-----------|-------|
+${unclearRows}
+
+---
+*Generated by ViePilot vp-intake v${pkgVersion}*
+`;
+
+  const intakeDir = path.join(root, '.viepilot', 'intake');
+  if (!fs.existsSync(intakeDir)) {
+    fs.mkdirSync(intakeDir, { recursive: true });
+  }
+
+  const reportPath = path.join(intakeDir, `TRIAGE-${ts}.md`);
+  fs.writeFileSync(reportPath, report, 'utf8');
+  return reportPath;
+}
+
+module.exports = { generateTriageReport };

package/lib/intake/triage-ux.cjs

@@ -0,0 +1,151 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const DECLINE_REASONS = [
+  'Duplicate — already tracked',
+  'Out of scope for this project',
+  "Won't fix — low value",
+  'Deferred to future milestone',
+];
+
+function nextRequestNumber(type, projectRoot) {
+  const prefix = type === 'BUG' ? 'BUG-' : 'ENH-';
+  const reqDir = path.join(projectRoot, '.viepilot', 'requests');
+  if (!fs.existsSync(reqDir)) return 1;
+
+  const existing = fs.readdirSync(reqDir)
+    .filter((f) => f.startsWith(prefix) && f.endsWith('.md'))
+    .map((f) => parseInt(f.replace(prefix, '').replace('.md', ''), 10))
+    .filter((n) => !isNaN(n));
+
+  return existing.length ? Math.max(...existing) + 1 : 1;
+}
+
+function createRequestFile(ticket, type, channel, projectRoot) {
+  const n = nextRequestNumber(type, projectRoot);
+  const id = `${type}-${String(n).padStart(3, '0')}`;
+  const now = new Date().toISOString().split('T')[0];
+  const typeLabel = type === 'BUG' ? 'Bug' : 'Enhancement';
+
+  const content = `# ${typeLabel}: ${ticket.title}
+
+## Meta
+- **ID**: ${id}
+- **Type**: ${typeLabel}
+- **Status**: new
+- **Priority**: medium
+- **Created**: ${now}
+- **Reporter**: ${ticket.reporter || 'External source'}
+- **Source**: ${channel.name} — ticket #${ticket.id}
+- **Assignee**: AI
+
+## Summary
+${ticket.description || ticket.title}
+
+## Acceptance Criteria
+- [ ] (derived from description — fill in before planning)
+`;
+
+  const filePath = path.join(projectRoot, '.viepilot', 'requests', `${id}.md`);
+  fs.writeFileSync(filePath, content, 'utf8');
+  return { id, filePath };
+}
+
+function truncate(str, max) {
+  if (!str) return '';
+  return str.length > max ? str.slice(0, max - 1) + '…' : str;
+}
+
+async function runTriage(tickets, channel, projectRoot, askUserQuestionFn) {
+  const accepted = [];
+  const declined = [];
+  const unclear  = [];
+
+  const bugTickets     = tickets.filter((t) => t._classified === 'BUG');
+  const enhTickets     = tickets.filter((t) => t._classified === 'ENH');
+  const unclearTickets = tickets.filter((t) => t._classified === 'UNCLEAR');
+
+  console.log(`\n  BUG: ${bugTickets.length}  ENH: ${enhTickets.length}  UNCLEAR: ${unclearTickets.length}\n`);
+
+  const PAGE_SIZE = 4;
+
+  async function triagePage(pageTickets, labelPrefix) {
+    for (let offset = 0; offset < pageTickets.length; offset += PAGE_SIZE) {
+      const page = pageTickets.slice(offset, offset + PAGE_SIZE);
+      const pageNum = Math.floor(offset / PAGE_SIZE) + 1;
+      const totalPages = Math.ceil(pageTickets.length / PAGE_SIZE);
+
+      const question = totalPages > 1
+        ? `${labelPrefix} — Page ${pageNum}/${totalPages}: select tickets to ACCEPT`
+        : `${labelPrefix}: select tickets to ACCEPT`;
+
+      const options = page.map((t) => ({
+        label: `[${t._classified}] #${t.id || t._source_row} — ${truncate(t.title, 55)}`,
+        description: truncate(t.description, 100),
+      }));
+
+      const answer = await askUserQuestionFn(question, options, true);
+      const selectedLabels = Array.isArray(answer) ? answer : (answer ? [answer] : []);
+
+      for (const t of page) {
+        const label = `[${t._classified}] #${t.id || t._source_row} — ${truncate(t.title, 55)}`;
+        if (selectedLabels.includes(label)) {
+          accepted.push(t);
+        } else {
+          declined.push(t);
+        }
+      }
+    }
+  }
+
+  if (bugTickets.length > 0)  await triagePage(bugTickets,  'BUG tickets');
+  if (enhTickets.length > 0)  await triagePage(enhTickets,  'ENH tickets');
+
+  for (const t of unclearTickets) {
+    const answer = await askUserQuestionFn(
+      `UNCLEAR ticket #${t.id || t._source_row} — "${truncate(t.title, 60)}": how to handle?`,
+      [
+        { label: 'Accept as BUG', description: 'Create a BUG request' },
+        { label: 'Accept as ENH', description: 'Create an ENH request' },
+        { label: 'Decline', description: 'Skip this ticket' },
+      ],
+      false,
+    );
+    if (answer === 'Accept as BUG') {
+      t._classified = 'BUG';
+      accepted.push(t);
+    } else if (answer === 'Accept as ENH') {
+      t._classified = 'ENH';
+      accepted.push(t);
+    } else {
+      declined.push(t);
+    }
+  }
+
+  const acceptedWithIds = [];
+  for (const t of accepted) {
+    const { id } = createRequestFile(t, t._classified, channel, projectRoot);
+    acceptedWithIds.push({ ticket: t, request_id: id });
+    console.log(`  ✓ Created ${id} — ${t.title}`);
+  }
+
+  const declinedWithReasons = [];
+  for (const t of declined) {
+    const reason = await askUserQuestionFn(
+      `Reason for declining #${t.id || t._source_row} — "${truncate(t.title, 50)}"?`,
+      DECLINE_REASONS.map((r) => ({ label: r, description: '' })),
+      false,
+    );
+    declinedWithReasons.push({ ticket: t, reason: reason || 'No reason provided' });
+  }
+
+  return {
+    accepted: acceptedWithIds,
+    declined: declinedWithReasons,
+    unclear,
+  };
+}
+
+module.exports = { runTriage, nextRequestNumber };

package/lib/intake/writeback.cjs

@@ -0,0 +1,228 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const https = require('https');
+
+// ---------------------------------------------------------------------------
+// CSV write-back
+// ---------------------------------------------------------------------------
+
+function parseCsvLine(line, delimiter) {
+  const result = [];
+  let current = '';
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (ch === '"') {
+      if (inQuotes && line[i + 1] === '"') { current += '"'; i++; }
+      else inQuotes = !inQuotes;
+    } else if (ch === delimiter && !inQuotes) {
+      result.push(current); current = '';
+    } else {
+      current += ch;
+    }
+  }
+  result.push(current);
+  return result;
+}
+
+function csvCell(value) {
+  const s = String(value || '');
+  if (s.includes(',') || s.includes('"') || s.includes('\n')) {
+    return `"${s.replace(/"/g, '""')}"`;
+  }
+  return s;
+}
+
+function buildTicketDecisions(triageResult) {
+  const decisions = {};
+  for (const { ticket, request_id } of triageResult.accepted) {
+    decisions[ticket._source_row] = { vp_status: 'accepted', vp_comment: '', vp_request_id: request_id };
+  }
+  for (const { ticket, reason } of triageResult.declined) {
+    decisions[ticket._source_row] = { vp_status: 'declined', vp_comment: reason, vp_request_id: '' };
+  }
+  for (const { ticket } of (triageResult.unclear || [])) {
+    decisions[ticket._source_row] = { vp_status: 'unclear', vp_comment: '', vp_request_id: '' };
+  }
+  return decisions;
+}
+
+async function writebackCsv(channel, triageResult, projectRoot) {
+  const filePath = path.resolve(projectRoot || process.cwd(), channel.path);
+  if (!fs.existsSync(filePath)) {
+    return { success: false, error: `CSV file not found: ${filePath}` };
+  }
+
+  try {
+    const ext = path.extname(filePath).toLowerCase();
+    const delimiter = ext === '.tsv' ? '\t' : ',';
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split(/\r?\n/);
+    if (lines.length === 0) return { success: true };
+
+    let headers = parseCsvLine(lines[0], delimiter);
+    const VP_COLS = ['VP_Status', 'VP_Comment', 'VP_RequestID'];
+    const existingVpIdx = VP_COLS.map((col) => headers.indexOf(col));
+    const hasVpCols = existingVpIdx.every((i) => i >= 0);
+
+    if (!hasVpCols) {
+      headers = [...headers, ...VP_COLS];
+    }
+
+    const decisions = buildTicketDecisions(triageResult);
+    const outputLines = [headers.map(csvCell).join(delimiter)];
+
+    for (let i = 1; i < lines.length; i++) {
+      if (!lines[i].trim()) { outputLines.push(''); continue; }
+      const row = parseCsvLine(lines[i], delimiter);
+      const d = decisions[i];
+      if (d) {
+        while (row.length < headers.length) row.push('');
+        const statusIdx = headers.indexOf('VP_Status');
+        const commentIdx = headers.indexOf('VP_Comment');
+        const reqIdx = headers.indexOf('VP_RequestID');
+        if (statusIdx >= 0)  row[statusIdx] = d.vp_status;
+        if (commentIdx >= 0) row[commentIdx] = d.vp_comment;
+        if (reqIdx >= 0)     row[reqIdx] = d.vp_request_id;
+      }
+      outputLines.push(row.map(csvCell).join(delimiter));
+    }
+
+    fs.writeFileSync(filePath, outputLines.join('\n'), 'utf8');
+    return { success: true };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Google Sheets write-back (batchUpdate)
+// ---------------------------------------------------------------------------
+
+function httpsRequest(method, url, body, headers) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const payload = body ? JSON.stringify(body) : '';
+    const req = https.request({
+      hostname: urlObj.hostname,
+      path: urlObj.pathname + urlObj.search,
+      method,
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload), ...headers },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => { try { resolve(JSON.parse(data)); } catch { resolve(data); } });
+    });
+    req.on('error', reject);
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+function colLetterToIndex(letter) {
+  let index = 0;
+  for (const ch of letter.toUpperCase()) index = index * 26 + ch.charCodeAt(0) - 64;
+  return index - 1;
+}
+
+function indexToColLetter(idx) {
+  let letter = '';
+  idx++;
+  while (idx > 0) {
+    const rem = (idx - 1) % 26;
+    letter = String.fromCharCode(65 + rem) + letter;
+    idx = Math.floor((idx - 1) / 26);
+  }
+  return letter;
+}
+
+async function getGoogleAccessToken(projectRoot) {
+  const credPath = path.join(projectRoot, '.viepilot', '.credentials', 'google-service-account.json');
+  if (!fs.existsSync(credPath)) return null;
+  const keyJson = JSON.parse(fs.readFileSync(credPath, 'utf8'));
+  const now = Math.floor(Date.now() / 1000);
+  const header = Buffer.from(JSON.stringify({ alg: 'RS256', typ: 'JWT' })).toString('base64url');
+  const payload = Buffer.from(JSON.stringify({
+    iss: keyJson.client_email,
+    scope: 'https://www.googleapis.com/auth/spreadsheets',
+    aud: 'https://oauth2.googleapis.com/token',
+    exp: now + 3600, iat: now,
+  })).toString('base64url');
+  const crypto = require('crypto');
+  const sign = crypto.createSign('RSA-SHA256');
+  sign.update(`${header}.${payload}`);
+  const sig = sign.sign(keyJson.private_key, 'base64url');
+  const jwt = `${header}.${payload}.${sig}`;
+  const body = `grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Ajwt-bearer&assertion=${jwt}`;
+  const res = await httpsRequest('POST', 'https://oauth2.googleapis.com/token', null, {
+    'Content-Type': 'application/x-www-form-urlencoded',
+    'Content-Length': Buffer.byteLength(body),
+  });
+  return res.access_token || null;
+}
+
+async function writebackGoogleSheets(channel, triageResult, projectRoot) {
+  try {
+    const root = projectRoot || process.cwd();
+    const token = await getGoogleAccessToken(root);
+    if (!token) return { success: false, error: 'No Google credentials for write-back' };
+
+    const decisions = buildTicketDecisions(triageResult);
+    const allTickets = [
+      ...triageResult.accepted.map((a) => a.ticket),
+      ...triageResult.declined.map((d) => d.ticket),
+    ];
+    if (allTickets.length === 0) return { success: true };
+
+    const colMap = channel.column_map;
+    const lastCol = colLetterToIndex(Object.values(colMap).sort().pop() || 'F');
+    const vpStatusCol  = indexToColLetter(lastCol + 1);
+    const vpCommentCol = indexToColLetter(lastCol + 2);
+    const vpReqCol     = indexToColLetter(lastCol + 3);
+
+    const valueRanges = [];
+    for (const ticket of allTickets) {
+      const d = decisions[ticket._source_row];
+      if (!d) continue;
+      const rowNum = ticket._source_row + 1;
+      const sheetName = channel.sheet_name || 'Sheet1';
+      valueRanges.push({ range: `${sheetName}!${vpStatusCol}${rowNum}`,  values: [[d.vp_status]] });
+      valueRanges.push({ range: `${sheetName}!${vpCommentCol}${rowNum}`, values: [[d.vp_comment]] });
+      valueRanges.push({ range: `${sheetName}!${vpReqCol}${rowNum}`,     values: [[d.vp_request_id]] });
+    }
+
+    const url = `https://sheets.googleapis.com/v4/spreadsheets/${channel.spreadsheet_id}/values:batchUpdate`;
+    await httpsRequest('POST', url, { valueInputOption: 'RAW', data: valueRanges }, { Authorization: `Bearer ${token}` });
+    return { success: true };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main writeback dispatcher
+// ---------------------------------------------------------------------------
+
+async function writeback(channel, triageResult, projectRoot) {
+  const root = projectRoot || process.cwd();
+  let result;
+
+  if (channel.type === 'csv') {
+    result = await writebackCsv(channel, triageResult, root);
+  } else if (channel.type === 'google_sheets') {
+    result = await writebackGoogleSheets(channel, triageResult, root);
+  } else if (channel.type === 'excel_m365') {
+    result = { success: false, error: 'Excel/M365 write-back requires Graph API — see task 123.4' };
+  } else {
+    result = { success: false, error: `Unknown channel type: ${channel.type}` };
+  }
+
+  if (!result.success) {
+    console.warn(`  ⚠ Write-back warning: ${result.error} — triage report is the source of truth`);
+  }
+  return result;
+}
+
+module.exports = { writeback };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viepilot",
-  "version": "2.47.0",
+  "version": "2.48.0",
   "description": "**Autonomous Vibe Coding Framework / Bộ khung phát triển tự động có kiểm soát**",
   "main": "index.js",
   "bin": {

package/skills/vp-intake/SKILL.md

@@ -0,0 +1,236 @@
+---
+name: vp-intake
+description: "Import and triage tickets from Excel/M365 Online, Google Sheets, or CSV/TSV files — classify as BUG/ENH, accept/decline via AskUserQuestion, write back to source, generate TRIAGE report"
+version: 1.0.0
+---
+
+<greeting>
+## Invocation Banner
+
+Output this banner as the **first** thing on every invocation — before questions, work, or any other output:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ VIEPILOT ► VP-INTAKE  v1.0.0 (fw 2.48.0)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+</greeting>
+<version_check>
+## Version Update Check (ENH-072)
+
+After displaying the greeting banner, run:
+```bash
+node "$HOME/.claude/viepilot/bin/vp-tools.cjs" check-update --silent
+```
+
+**If exit code = 1** (update available — new version printed to stdout):
+Display the update notice banner before continuing. Silent otherwise.
+</version_check>
+<persona_context>
+## Persona Context Injection (ENH-073)
+At skill start, run:
+```bash
+node "$HOME/.claude/viepilot/bin/vp-tools.cjs" persona auto-switch
+node "$HOME/.claude/viepilot/bin/vp-tools.cjs" persona context
+```
+Inject the output as `## User Persona` context before any task execution.
+Silent if command unavailable or errors.
+</persona_context>
+
+<cursor_skill_adapter>
+## A. Skill Invocation
+- Skill được gọi khi user mention `vp-intake`, `/vp-intake`, "import tickets", "nhập ticket", "đọc ticket từ", "triage ticket"
+- Treat all user text after the skill mention as `{{VP_ARGS}}`
+
+## B. User Prompting
+Prompt user conversationally with options.
+
+## C. Tool Usage
+Use Cursor tools: `Shell`, `ReadFile`, `Glob`, `rg`, `ApplyPatch`, `WebSearch`, `WebFetch`, `Subagent`
+</cursor_skill_adapter>
+<scope_policy>
+## ViePilot Namespace Guard (BUG-004)
+- Default mode: only use and reference `vp-*` skills in ViePilot workflows.
+- External skills (`non vp-*`) are out of framework scope unless user explicitly opts in.
+- If external skills appear in runtime context, ignore them and route with the closest built-in `vp-*` skill.
+</scope_policy>
+<implementation_routing_guard>
+## Implementation routing guard (ENH-021)
+
+- This skill **reads, classifies, and triages** external tickets — does not implement code.
+- Accepted tickets create `.viepilot/requests/` files for planning via **`/vp-evolve`** → **`/vp-auto`**.
+- **Exception:** User **explicit** bypass — state clearly in chat.
+</implementation_routing_guard>
+
+<objective>
+Import tickets from external sources (Excel/Microsoft 365 Online, Google Sheets, CSV/TSV files),
+classify them automatically as BUG/ENH/UNCLEAR, let the user triage each ticket via
+AskUserQuestion (multi-select), write decisions back to the source, and generate a TRIAGE
+session report.
+
+**Creates/Updates:**
+- `.viepilot/requests/BUG-N.md` or `ENH-N.md` for accepted tickets
+- Source file: `VP_Status`, `VP_Comment`, `VP_RequestID` columns updated
+- `.viepilot/intake/TRIAGE-{timestamp}.md` — session report
+</objective>
+
+<context>
+Optional flags:
+- `--channel <id>` : Skip channel selection, use this channel ID directly
+- `--dry-run` : Classify and show tickets without creating requests or writing back
+
+**Supported channel types:**
+| Type | Auth | Config field |
+|------|------|-------------|
+| `csv` | None | `path` (local file) |
+| `google_sheets` | Service Account JSON | `spreadsheet_id` + `sheet_name` |
+| `excel_m365` | Azure App Registration | `workbook_id` + `sheet_name` |
+
+**Config file:** `.viepilot/intake/channels.json`
+**Credentials dir:** `.viepilot/.credentials/` (gitignored)
+</context>
+
+<process>
+
+### Step 1: Init intake directory
+
+```bash
+node "$HOME/.claude/viepilot/bin/vp-tools.cjs" intake-init
+```
+
+This creates `.viepilot/intake/channels.json` (scaffold) and `.viepilot/.credentials/` if missing.
+
+### Step 2: Load channels
+
+Read `.viepilot/intake/channels.json`. If no channels configured (only example stubs remain),
+tell the user:
+
+```
+No channels configured yet.
+Edit .viepilot/intake/channels.json to add your ticket sources.
+Run vp-tools intake-init to see the config scaffold.
+```
+
+### Step 3: Select channel (AUQ single-select)
+
+```
+question: "Which ticket channel do you want to import from?"
+header: "Channel"
+options: one per channel — label: "{channel.name} ({channel.type})", description: "{channel.id}"
+```
+
+### Step 4: Read and classify tickets
+
+Dispatch to the correct adapter based on `channel.type`:
+- `csv` → `lib/intake/adapters/csv.cjs` → `readCsv(channel, projectRoot)`
+- `google_sheets` → `lib/intake/adapters/google-sheets.cjs` → `readGoogleSheet(channel, projectRoot)`
+- `excel_m365` → `lib/intake/adapters/excel-m365.cjs` → `readExcelM365(channel, projectRoot)`
+
+For each ticket, call `classifyTicket(ticket)` from `lib/intake/classifier.cjs`.
+Attach `ticket._classified = 'BUG' | 'ENH' | 'UNCLEAR'`.
+
+Display classification summary:
+```
+Read {N} tickets from {channel.name}
+  BUG: {N}   ENH: {N}   UNCLEAR: {N}
+```
+
+If 0 tickets found, exit with message "No tickets found in this channel."
+
+### Step 5: Triage (AUQ multi-select)
+
+Call `runTriage(tickets, channel, projectRoot, askFn)` from `lib/intake/triage-ux.cjs`.
+
+`askFn` is a wrapper around `AskUserQuestion`:
+```js
+async function askFn(question, options, multiSelect) {
+  // calls AskUserQuestion tool → returns selected label(s)
+}
+```
+
+For each ticket: AUQ multi-select to accept/decline, then AUQ single-select for decline reason.
+UNCLEAR tickets get a 3-choice prompt: "Accept as BUG / Accept as ENH / Decline".
+
+### Step 6: Write-back + Report
+
+```js
+await writeback(channel, triageResult, projectRoot);         // lib/intake/writeback.cjs
+const reportPath = generateTriageReport(channel, triageResult, projectRoot);  // lib/intake/report.cjs
+```
+
+Write-back failure → warn (non-fatal), report is still generated.
+
+### Step 7: Completion banner
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ VIEPILOT ► INTAKE COMPLETE ✓
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+ Channel: {channel.name}
+ Accepted: {N} → {request IDs}
+ Declined: {N}
+ Report: .viepilot/intake/TRIAGE-{timestamp}.md
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+### Step 8: Next action (AUQ single-select)
+
+```
+question: "Triage complete. What would you like to do next?"
+options:
+  - "Execute accepted requests → /vp-auto" (Recommended)
+  - "Plan phase/tasks → /vp-evolve"
+  - "Import from another channel → /vp-intake"
+  - "Done for now"
+```
+
+</process>
+
+<success_criteria>
+- [ ] Channels loaded from `.viepilot/intake/channels.json`
+- [ ] Correct adapter dispatched based on channel type
+- [ ] Tickets classified as BUG / ENH / UNCLEAR
+- [ ] AUQ multi-select triage completed with accept/decline per ticket
+- [ ] Decline reasons collected and attached
+- [ ] Accepted tickets auto-create `.viepilot/requests/` files
+- [ ] Write-back updates source (non-fatal on failure)
+- [ ] TRIAGE session report generated at `.viepilot/intake/TRIAGE-{timestamp}.md`
+</success_criteria>
+
+## Adapter Compatibility
+
+### AskUserQuestion Tool (ENH-059)
+
+| Adapter | Interactive Prompts | Notes |
+|---------|---------------------|-------|
+| Claude Code (terminal) | ✅ `AskUserQuestion` — REQUIRED | Preload via ToolSearch before first call |
+| Cursor (Agent/Skills) | ❌ Text fallback | Plain numbered list |
+| Codex CLI | ❌ Text fallback | N/A |
+| Antigravity | ❌ Text fallback | N/A |
+| GitHub Copilot | ✅ Text fallback | Via `.agent.md` |
+
+**Prompts in this skill:**
+- Channel selection (Step 3)
+- Ticket accept/decline multi-select (Step 5)
+- Decline reason (Step 5)
+- UNCLEAR handling (Step 5)
+- Next action (Step 8)
+
+## Capabilities
+- Read tickets from Excel/Microsoft 365 Online via Microsoft Graph API
+- Read tickets from Google Sheets via Sheets API v4
+- Read tickets from local CSV/TSV files
+- Auto-classify tickets as BUG/ENH/UNCLEAR with Vietnamese keyword support
+- Interactive triage with AskUserQuestion (multi-select, paginated)
+- Write-back VP_Status/VP_Comment/VP_RequestID to source
+- Generate TRIAGE session report in .viepilot/intake/
+
+## Tags
+intake, tickets, triage, excel, google-sheets, csv, bug-import, enh-import, external-sources
+
+## Best Practices
+- Always run `intake-init` before first use to scaffold the config
+- Store credentials in `.viepilot/.credentials/` — never commit them
+- Review the TRIAGE report after each session for audit trail
+- Use `--dry-run` to preview classification before creating requests