viepilot 2.45.6 → 2.48.0

package/CHANGELOG.md

@@ -7,6 +7,90 @@ 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
+- **ENH-081** Brownfield Scan Trace Log — `BROWNFIELD-TRACE.md` real-time trace artifact
+  (`workflows/crystallize.md`). Before any signal category scanning begins, crystallize now
+  writes `.viepilot/BROWNFIELD-TRACE.md` to disk with all 13 categories pre-populated as
+  `planned`. Full feature set:
+  - **Trace initialization + resume detection**: on session start, checks for existing trace;
+    if `Status: scan_complete` → AUQ offers skip re-scan or re-scan from scratch; if trace is
+    mid-scan (interrupted) → AUQ offers resume from the last completed signal category
+  - **Per-Category Update Protocol (ENH-081)**: on category start → row moves to `scanning`;
+    on completion → row moves to `done`/`assumed`/`skipped` with file count, signals found,
+    start time, and duration; `## Files Read Log` appended with `[x]` (read) / `[ ]` (not found)
+    per file probed
+  - **Coverage gate (ENH-081)**: before presenting Scan Report, counts remaining `planned` rows;
+    non-blocking warning if any categories were not executed; sets `Status: scan_complete` in
+    trace header after gate passes
+  - **Gap Filling Log (ENH-081)**: each user response during Step 0-B-ii gap-filling is
+    immediately appended to `## Gap Filling Log` — no batching
+  - **Step Completion tracking**: `## Step Completion` rows updated after Step 0-C (Brainstorm
+    Stub) and Step 0-D (UI Workspace, 3 cases: done / skipped / N/A)
+
+## [2.46.1] - 2026-05-06
+
+### Fixed
+- **ENH-080** Upgrade re-scan (ENH-067 Step 0-B) now detects Signal Category 13 gap for
+  projects crystallized before v2.46.0:
+  - Delta computation table extended with `v2.46.0` row: detection field `ui_signals_imported`
+    absent from HANDOFF.json; trigger re-check prevents false-positive for backend-only projects
+    (no CSS, no Tailwind, no UI component files)
+  - Step 0-D now persists `ui_signals_imported: true/false` + `ui_signals_imported_at`/
+    `ui_signals_skipped_at` to `HANDOFF.json` after workspace generation or skip — marks gap
+    as "evaluated"; prevents re-asking on every crystallize run; `--upgrade` forces re-evaluation
+  - Patch mode handler added: re-runs Signal Cat 13 (Sub-scans A/B/C) + Step 0-D when UI gap
+    detected; AUQ gate preserved; no brainstorm supplement check (reads codebase directly)
+
+## [2.46.0] - 2026-04-27
+
+### Added
+- **ENH-079** Signal Category 13 — UI/Design System Signals in brownfield scanner
+  (`workflows/crystallize.md`). When an existing project has a real UI layer, the
+  brownfield scan now reverse-engineers it into a complete `.viepilot/ui-direction/`
+  workspace automatically:
+  - Sub-scan A: CSS custom properties (`--color-*`, `--font-*`, `--spacing-*`, `--radius-*`),
+    Tailwind config (`theme.extend.colors`, `fontFamily`, `spacing`, `borderRadius`),
+    SCSS variables, design token JSON files → Design.MD v1 `design.md`
+  - Sub-scan B: Page/route inventory for 8 framework types (Next.js App Router, Next.js Pages
+    Router, React Router, Vue Router, Angular, Nuxt 3, SvelteKit, plain HTML) →
+    `index.html` hub + `pages/{slug}.html` stubs per discovered route
+  - Sub-scan C: Component inventory via file glob + UI library detection from `package.json`
+    (shadcn/ui, Material UI, Chakra UI, Ant Design, Headless UI, Bootstrap, Radix) →
+    `notes.md ## components_inventory`
+  - AUQ gate: "Generate ui-direction workspace?" before reverse-engineering (skippable)
+  - Scan Report `ui_signals` field: `triggered`, `workspace_generated`, `ui_tokens`,
+    `ui_pages`, `ui_components`
+  - `notes.md` front matter: `reverse_engineered: true` flag — distinguishes auto-generated
+    sessions from manually crafted brainstorm sessions
+  - `workflows/brainstorm.md` Step 3C: imports Signal 13 data when brownfield stub contains
+    `ui_signals`; handles 3 cases (workspace generated / data present / not triggered);
+    offers on-demand workspace generation via AUQ
+
 ## [2.45.6] - 2026-04-27
 
 ### Fixed

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 };