@relipa/ai-flow-kit 0.0.7-beta.0 → 0.0.7-beta.1

package/README.md

@@ -16,7 +16,7 @@ Developers only need a single command to load ticket context → AI automaticall
 | New plugins (superpowers, MCP...) require manual setup | Package auto-sets up hooks, skills, and MCP on init |
 | Missing investigation / bug reproduction flow | Skill `investigate-bug` (inherits systematic-debugging) |
 | Missing impact analysis flow | Skill `impact-analysis` |
-| Hard to resume tasks | **State Resumption**: Unified `plan/` docs and context across tools |
+| Hard to resume tasks | **State Resumption**: Unified `plan/` docs, `task-summary.md` progress tracking, and intelligent session continuity (automatic Gate 3 resumption). |
 
 ## Documentation & Guides
 
@@ -123,7 +123,7 @@ aiflow init --framework spring-boot,reactjs --adapter backlog,jira
 - `.mcp.json` + Claude Desktop config — MCP adapter
 - `.aiflow/credentials.json` — save API credentials
 
-**Supported Frameworks:** `spring-boot`, `laravel`, `reactjs`, `nextjs`, `vue-nuxt`
+**Supported Frameworks:** `spring-boot`, `laravel`, `php-plain`, `nestjs`, `reactjs`, `nextjs`, `vue-nuxt`, `nodejs-express`, `python-django`, `python-fastapi`
 
 **Supported Adapters:** `backlog`, `jira`, `google-sheets`, `figma`
 
@@ -172,7 +172,7 @@ aiflow use PROJ-33 --comments-from 3
 aiflow use --manual
 
 # Load from local file (JSON or plain text)
-aiflow use --file task.md
+aiflow use --file task.md      # Auto-generates taskId from filename & prompts for taskType
 
 # Modes (Fast is default)
 aiflow use PROJ-33          # Fast Mode: skip Q&A, target < 5 min
@@ -305,9 +305,14 @@ aiflow memory list
 |-----------|---------|--------------|
 | `spring-boot` | Java 17+ | `rules/java/` |
 | `laravel` | PHP 8.1+ | `rules/php/` |
+| `php-plain` | PHP 8.1+ (no framework) | `rules/php/` |
+| `nestjs` | TypeScript | `rules/javascript/` |
 | `reactjs` | TypeScript | `rules/javascript/` |
 | `nextjs` | TypeScript | `rules/javascript/` |
 | `vue-nuxt` | TypeScript | `rules/javascript/` |
+| `nodejs-express` | JavaScript/TypeScript | `rules/javascript/` |
+| `python-django` | Python | — |
+| `python-fastapi` | Python | — |
 
 ---
 

package/bin/aiflow.js

@@ -278,6 +278,13 @@ program
             command: `gate${gateNum}.${action}`,
             ai_tool: options.aiTool || ''
         });
+
+        if (action === 'approved') {
+            console.log(chalk.cyan(`\n  Gate ${gateNum} approved!`));
+            console.log(chalk.yellow(`  Pro-Tip: To avoid context pollution, it's recommended to start a fresh chat session.`));
+            console.log(chalk.gray(`  Run: aiflow task next${options.ticket ? ` --ticket ${options.ticket}` : ''} to save progress,`));
+            console.log(chalk.gray(`  then open a NEW chatbox and type "continue".\n`));
+        }
     });
 
 // ── remove ────────────────────────────────────────────────────

package/custom/skills/investigate-bug/SKILL.md

@@ -50,6 +50,23 @@ Route / Controller
         → Database
 ```
 
+**NestJS**
+```
+Controller (@Controller)
+  → Service (@Injectable)
+    → Repository / TypeORM Entity
+      → Database
+```
+
+**PHP Plain (no framework)**
+```
+index.php (router)
+  → Controller
+    → Service
+      → Repository (PDO)
+        → Database
+```
+
 **React / Next.js**
 ```
 Page / Route component

package/custom/templates/php-plain.md

@@ -0,0 +1,261 @@
+# PHP Plain AI System Prompt
+
+You are an expert PHP developer working with plain PHP (no framework). Follow these rules to produce clean, secure, maintainable code.
+
+---
+
+## Architecture
+
+Organise code in a layered structure. Avoid writing logic directly in view files.
+
+```
+public/              # Web root — index.php, assets
+src/
+├── Controller/      # Handle HTTP request/response
+├── Service/         # Business logic
+├── Repository/      # Data access (PDO queries)
+├── Model/           # Plain data objects / DTOs
+├── Middleware/       # Auth, CORS, rate limiting
+├── Exception/       # Custom exceptions
+└── Config/          # DB, env, constants
+templates/           # HTML view files (.php/.html)
+```
+
+---
+
+## Coding Rules
+
+### General
+
+- Use **PHP 8.1+** features: named arguments, enums, readonly properties, fibers where appropriate.
+- Always declare strict types at the top of every file: `declare(strict_types=1);`
+- Use **constructor promotion** for clean dependency injection.
+- Follow **PSR-12** coding style.
+- Prefer `match` over long `switch` blocks.
+- Never suppress errors with `@` — handle them properly.
+
+```php
+// ✅ Good
+declare(strict_types=1);
+
+class UserService
+{
+    public function __construct(
+        private readonly UserRepository $userRepository,
+    ) {}
+
+    public function findById(int $id): UserDto
+    {
+        $user = $this->userRepository->findById($id);
+        if ($user === null) {
+            throw new NotFoundException("User $id not found");
+        }
+        return UserDto::fromArray($user);
+    }
+}
+
+// ❌ Bad — no strict types, logic in global scope
+$pdo = new PDO(...);
+$user = $pdo->query("SELECT * FROM users WHERE id = $_GET[id]")->fetch();
+echo $user['name'];
+```
+
+---
+
+### Security Rules (CRITICAL)
+
+- **NEVER** interpolate user input into SQL — always use **PDO prepared statements**.
+- **NEVER** output user input without escaping — always use `htmlspecialchars()`.
+- Validate and sanitize ALL user input at the controller/entry boundary.
+- Store passwords with `password_hash($pass, PASSWORD_BCRYPT)`, verify with `password_verify()`.
+- Use `random_bytes()` / `bin2hex(random_bytes(32))` for tokens — never `rand()` or `md5()`.
+- Always validate uploaded file MIME types server-side — never trust the browser.
+
+```php
+// ✅ Good — prepared statement
+$stmt = $pdo->prepare('SELECT * FROM users WHERE email = :email');
+$stmt->execute([':email' => $email]);
+$user = $stmt->fetch(PDO::FETCH_ASSOC);
+
+// ✅ Good — safe HTML output
+echo htmlspecialchars($user['name'], ENT_QUOTES, 'UTF-8');
+
+// ❌ Bad — SQL injection
+$result = $pdo->query("SELECT * FROM users WHERE email = '$email'");
+```
+
+---
+
+### Database / Repository Rules
+
+- All DB access goes through Repository classes — never call PDO from controllers or services.
+- Use PDO with `PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION`.
+- Wrap multi-step writes in transactions.
+- Return plain arrays or typed DTO objects from repositories — never raw `PDOStatement`.
+
+```php
+// ✅ Good
+class UserRepository
+{
+    public function __construct(private readonly \PDO $pdo) {}
+
+    public function findByEmail(string $email): ?array
+    {
+        $stmt = $this->pdo->prepare(
+            'SELECT id, email, full_name FROM users WHERE email = :email AND deleted = 0'
+        );
+        $stmt->execute([':email' => $email]);
+        $row = $stmt->fetch(\PDO::FETCH_ASSOC);
+        return $row ?: null;
+    }
+
+    public function create(string $email, string $fullName, string $passwordHash): int
+    {
+        $stmt = $this->pdo->prepare(
+            'INSERT INTO users (email, full_name, password_hash) VALUES (:email, :full_name, :password_hash)'
+        );
+        $stmt->execute([
+            ':email'         => $email,
+            ':full_name'     => $fullName,
+            ':password_hash' => $passwordHash,
+        ]);
+        return (int) $this->pdo->lastInsertId();
+    }
+}
+```
+
+---
+
+### Controller Rules
+
+- Controllers handle HTTP only: parse input, call service, output response.
+- Never put business logic or direct DB calls in controllers.
+- Validate input before passing to the service layer.
+- For JSON APIs: always set `Content-Type: application/json` and return consistent response shape.
+
+```php
+// ✅ Good
+declare(strict_types=1);
+
+class UserController
+{
+    public function __construct(private readonly UserService $userService) {}
+
+    public function create(): void
+    {
+        $body = json_decode(file_get_contents('php://input'), true) ?? [];
+        $email    = trim($body['email'] ?? '');
+        $fullName = trim($body['full_name'] ?? '');
+        $password = $body['password'] ?? '';
+
+        if ($email === '' || !filter_var($email, FILTER_VALIDATE_EMAIL)) {
+            http_response_code(400);
+            echo json_encode(['error' => 'Invalid email']);
+            return;
+        }
+
+        $user = $this->userService->create($email, $fullName, $password);
+        http_response_code(201);
+        echo json_encode($user);
+    }
+}
+```
+
+---
+
+### Error Handling
+
+- Define custom exception classes (`NotFoundException`, `ValidationException`, etc.).
+- Register a global exception handler via `set_exception_handler()`.
+- Never expose stack traces or internal paths to the client.
+- Log errors to a file/syslog with a timestamp and context.
+
+```php
+// ✅ Good — centralised handler
+set_exception_handler(function (\Throwable $e): void {
+    $status = match (true) {
+        $e instanceof NotFoundException      => 404,
+        $e instanceof ValidationException    => 422,
+        $e instanceof UnauthorizedException  => 401,
+        default                              => 500,
+    };
+    http_response_code($status);
+    header('Content-Type: application/json');
+    if ($status === 500) {
+        error_log($e->getMessage() . ' ' . $e->getTraceAsString());
+        echo json_encode(['error' => 'Internal server error']);
+    } else {
+        echo json_encode(['error' => $e->getMessage()]);
+    }
+});
+```
+
+---
+
+### Autoloading
+
+- Use **Composer autoload** (PSR-4) — no manual `require` chains.
+- `composer.json` minimum:
+
+```json
+{
+    "autoload": {
+        "psr-4": {
+            "App\\": "src/"
+        }
+    }
+}
+```
+
+---
+
+## Naming Conventions
+
+| Element | Convention | Example |
+|---------|-----------|---------|
+| Class | PascalCase | `UserService`, `OrderRepository` |
+| Method | camelCase | `findById`, `createOrder` |
+| Variable | camelCase | `$userId`, `$orderList` |
+| Constant | UPPER_SNAKE_CASE | `MAX_LOGIN_ATTEMPTS` |
+| DB table | snake_case | `user_orders` |
+| DB column | snake_case | `created_at` |
+| File | Matches class name | `UserService.php` |
+
+---
+
+## Testing Rules
+
+- Use **PHPUnit** for unit and integration tests.
+- Test class mirrors source path: `tests/Service/UserServiceTest.php`.
+- Mock dependencies with `$this->createMock()` or a stub.
+- Cover: happy path, validation errors, not-found cases.
+
+```php
+class UserServiceTest extends TestCase
+{
+    public function testCreateThrowsOnDuplicateEmail(): void
+    {
+        $repo = $this->createMock(UserRepository::class);
+        $repo->method('findByEmail')->willReturn(['id' => 1]);
+
+        $service = new UserService($repo);
+
+        $this->expectException(ValidationException::class);
+        $service->create('dup@example.com', 'Test', 'password');
+    }
+}
+```
+
+---
+
+## Anti-Patterns to Avoid
+
+- ❌ Raw SQL in controllers or views
+- ❌ User input directly in SQL / HTML output
+- ❌ Global `$_GET` / `$_POST` access outside the controller boundary
+- ❌ `die()` / `exit()` for error handling — use exceptions
+- ❌ Storing plain-text passwords
+- ❌ `include`/`require` inside business logic — use autoloading
+- ❌ Logic-heavy view files (`.php` templates should only render)
+
+When explaining changes, refer to the [PHP Manual](https://www.php.net/manual) and [PSR standards](https://www.php-fig.org/psr/).

package/docs/common/AIFLOW.md

@@ -65,7 +65,10 @@ AI Flow Kit allows you to manage multiple tasks in the same repository without l
 - **`aiflow task pause`**: Save current context and gate progress to `.aiflow/tasks/<taskId>/`.
 - **`aiflow task switch <id>`**: Pause current task and switch to another.
 - **`aiflow task resume <id>`**: Restore context and gate state. AI auto-resumes from the correct gate.
-- **`aiflow task next`**: Approve the current gate, clear context, and prepare the task for a fresh session (saves tokens).
+- **`aiflow task next`**: Approve the current gate, generate `task-summary.md`, clear active context, and prepare the task for a fresh session (Recommended to avoid context pollution).
+
+### Pro-Tip: Fresh Session Workflow
+For the best AI performance, run `aiflow task next` after every gate approval, then open a **new chatbox** and type "continue". This clears out long chat history that might confuse the AI.
 
 ---
 
@@ -502,6 +505,8 @@ A: Yes. Use `aiflow task pause` to save your current progress, then `aiflow use
 
 **Q: If I resume a task, will Claude know which gate to start at?**
 A: Yes. The SessionStart hook reads `.aiflow/tasks/<taskId>/task-state.json` and injects gate-aware instructions. If Gate 1 was already approved, Claude will skip to Gate 2, and so on.
+**Q: Can I resume a Gate 3 (Code Generation) task in a new chatbox?**
+A: Yes. Gate 3 progress is saved via `[x]` checkboxes in `plan/[id]/plan.md`. If you open a new chatbox and say "continue", the AI will automatically skip completed tasks and pick up exactly where it left off.
 
 **Q: How does AI estimate effort?**
 A: AI analyzes the scope of changes (files affected, complexity, test requirements) and categorizes: S (< 1h), M (1-4h), L (4-8h), XL (8h+, should split).

package/docs/common/CHANGELOG.md

@@ -7,10 +7,20 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ---
 
-## [0.0.7] - 2026-05-07
+## [0.0.7] - 2026-05-08
 
 ### Added
 
+- **`aiflow use --file` enhancements**:
+  - Automatic `taskId` generation from filename (up to 5 words).
+  - Full filename used as task `title`.
+  - Interactive `taskType` selection prompt during file loading for better context.
+- **`documentation` task type** — Added support for documentation-specific tasks in `aiflow use` and task detection.
+- **Automatic `task-summary.md` generation** — `aiflow task next` now generates a cumulative progress report in `plan/[ticket-id]/task-summary.md` at each gate finish.
+- **Session Continuity Instructions** — Added explicit instructions on how to switch to a fresh chat session and resume tasks (including Gate 3 sub-tasks) to both CLI output and AI skill prompts.
+- **NestJS framework support** — Added `nestjs` to the framework selector (`aiflow init`), language rule mapping (`javascript`), and AI instruction template (`custom/templates/nestjs.md`).
+- **PHP Plain (no framework) support** — Added `php-plain` as a new framework option with a dedicated AI system prompt template covering strict types, PSR-12, PDO prepared statements, security best practices, Repository/Service/Controller layering, and PHPUnit testing.
+- **`investigate-bug` skill: NestJS and PHP plain data flows** — Added framework-specific data flow traces for NestJS (`Controller → Service → Repository → DB`) and PHP Plain (`index.php → Controller → Service → Repository/PDO → DB`).
 - **Intelligent AI Instruction Synchronization** — Marker-based (`<!-- aiflow-kit-start -->`) block updates for `CLAUDE.md`, `GEMINI.md`, and `.cursorrules`.
 - **Interactive Instruction Safety** — Granular confirmation prompts for all instruction file modifications (update block, overwrite, or create new).
 - **Automated Repository Hygiene** — Generated files and folders (`.aiflow/`, `plan/`, `.claude/`, `.rules/`, `.mcp.json`, and instruction files) are now automatically managed in `.gitignore`.
@@ -20,6 +30,8 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Changed
 
+- **Robust Gate Detection** — Refactored `detectCurrentGate` to prioritize `task-state.json` as the source of truth for task progress.
+- **`aiflow gate approved` CLI output** — Now prints a session-refresh tip to help users maintain clean AI contexts.
 - **`aiflow update` efficiency** — Now automatically performs skill and instruction synchronization even if the version is unchanged (removes the need for `--force`).
 - **Safety First Development** — Removed all automatic `git commit` instructions from AI skills (`subagent-driven-development`, `using-git-worktrees`, `writing-plans`) to ensure developer-led commit management.
 - **Localized CLI** — All interactive prompts and confirmation messages translated to English for consistency.
@@ -29,6 +41,8 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Fixed
 
+- **NestJS auto-detection** — `@nestjs/core` in `package.json` was incorrectly detected as `nodejs-express`; now correctly resolves to `nestjs`.
+- **PHP project auto-detection** — Projects with `composer.json` but no Laravel dependency now correctly auto-detect as `php-plain` instead of being skipped.
 - Fixed `.github/copilot-instructions.md` not being included in automated `.gitignore` rules.
 
 ---

package/docs/common/QUICK_START.md

@@ -216,9 +216,9 @@ Ask a teammate to review. They can use `superpowers:receiving-code-review` skill
 
 After peer reviewer approves → merge → task complete.
 
-### Step 9: Task Management (Context Switching)
+### Step 9: Task Management & Session Continuity
 
-If you need to switch to another task mid-flow:
+Manage multiple tasks and ensure clean transitions between gates to prevent "context pollution" in long AI sessions.
 
 ```bash
 # Pause current task (saves gate progress)
@@ -229,8 +229,26 @@ aiflow task list
 
 # Resume a previously paused task
 aiflow task resume PROJ-33
+
+# Approve gate and prepare for fresh session (Recommended)
+aiflow task next
 ```
 
+#### Best Practice: Refreshing Sessions
+To keep the AI focused and avoid context pollution (where the AI gets confused by long chat history), it is recommended to start a **fresh chat session** after completing each gate.
+
+1. Run `aiflow task next` in your terminal to approve the current gate.
+2. Open a **NEW chatbox** (Claude UI, Cursor, etc.).
+3. Run `aiflow task resume [ticket-id]` (if not already active).
+4. Type **"continue"** — the AI will read the latest state and start the next gate with a clean slate.
+
+#### Resuming Gate 3 (Code Generation)
+If you need to switch chatboxes in the middle of a complex coding task (Gate 3):
+- Gate 3 progress is saved via `[x]` checkboxes in the plan file (`plan/[id]/plan.md`).
+- Simply open a new chatbox, run `aiflow task resume`, and tell the AI to **"continue executing the plan"**.
+- The AI will automatically skip finished tasks and pick up exactly where you left off.
+
+
 ---
 
 ## Workflow Summary Diagram

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relipa/ai-flow-kit",
-  "version": "0.0.7-beta.0",
+  "version": "0.0.7-beta.1",
   "description": "All-in-one AI Flow Kit for team development with Claude AI - skills, templates, and MCP adapters",
   "author": "Example Team",
   "publishConfig": {

package/scripts/init.js

@@ -24,10 +24,12 @@ function commandExists(cmd) {
 // Map framework → language family for picking the right rules
 const FRAMEWORK_LANGUAGE = {
     'laravel':      'php',
+    'php-plain':    'php',
     'spring-boot':  'java',
     'reactjs':      'javascript',
     'nextjs':       'javascript',
     'vue-nuxt':     'javascript',
+    'nestjs':       'javascript',
 };
 
 const AI_TOOL_FILES = {
@@ -65,7 +67,7 @@ async function detectFramework(projectDir) {
         if (deps['next'])          return 'nextjs';
         if (deps['nuxt'])          return 'vue-nuxt';
         if (deps['vue'])           return 'vue-nuxt';
-        if (deps['@nestjs/core'])  return 'nodejs-express';
+        if (deps['@nestjs/core'])  return 'nestjs';
         if (deps['react'])         return 'reactjs';
         if (deps['express'] || deps['fastify']) return 'nodejs-express';
     }
@@ -78,6 +80,7 @@ async function detectFramework(projectDir) {
     if (await fs.pathExists(composerPath)) {
         const composer = await fs.readJson(composerPath).catch(() => ({}));
         if ((composer.require || {})['laravel/framework']) return 'laravel';
+        return 'php-plain';
     }
     // Python
     if (await fs.pathExists(path.join(projectDir, 'manage.py'))) return 'python-django';
@@ -96,6 +99,8 @@ const FRAMEWORK_CHOICES = [
     { name: 'Next.js',            value: 'nextjs' },
     { name: 'Vue / Nuxt',         value: 'vue-nuxt' },
     { name: 'Laravel (PHP)',      value: 'laravel' },
+    { name: 'PHP (no framework)',        value: 'php-plain' },
+    { name: 'NestJS',             value: 'nestjs' },
     { name: 'Node.js / Express',  value: 'nodejs-express' },
     { name: 'Python Django',      value: 'python-django' },
     { name: 'Python FastAPI',     value: 'python-fastapi' },

package/scripts/task.js

@@ -345,13 +345,23 @@ async function nextGate(taskId) {
     // Clear current context so no task is "active"
     await fs.remove(CURRENT_FILE);
 
+    // Generate cumulative task-summary.md
+    const planDir = path.join(PROJECT_DIR, 'plan', resolvedId);
+    await fs.ensureDir(planDir);
+    const summaryPath = path.join(planDir, 'task-summary.md');
+    const summaryContent = await generateMarkdownSummary(taskState);
+    await fs.writeFile(summaryPath, summaryContent, 'utf-8');
+
     const gateLabels = { 1: 'Analyze', 2: 'Plan', 3: 'Code', 4: 'Review', 5: 'PR' };
     console.log(chalk.green(`✓ Gate ${currentGate} approved for ${resolvedId}.`));
+    console.log(chalk.gray(`  Summary saved to: plan/${resolvedId}/task-summary.md`));
     console.log(chalk.white(`\n  Next: Gate ${nextGateNum} — ${gateLabels[nextGateNum] || 'Done'}`));
-    console.log(chalk.cyan('\n  To start Gate ' + nextGateNum + ' in a fresh session:'));
-    console.log(chalk.gray('    1. Open a new terminal or chat session'));
-    console.log(chalk.gray(`    2. Run: aiflow task resume ${resolvedId}`));
-    console.log(chalk.gray(`    3. Claude/AI will automatically start Gate ${nextGateNum} with clean context`));
+    console.log(chalk.cyan(`\n  To continue in a fresh session (Recommended to avoid context pollution):`));
+    console.log(chalk.gray(`    1. Open a NEW chatbox or terminal session.`));
+    console.log(chalk.gray(`    2. Run: aiflow task resume ${resolvedId} (to load context).`));
+    console.log(chalk.gray(`    3. Type "start" or "continue from the current plan".`));
+    console.log(chalk.yellow(`       (Note: Gate 3 progress is saved via [x] checkboxes in plan.md.`));
+    console.log(chalk.yellow(`        The AI will automatically resume the exact task you left off.)`));
     console.log();
 }
 
@@ -375,6 +385,12 @@ async function loadAllTaskStates() {
 }
 
 async function detectCurrentGate(taskId) {
+    const statePath = path.join(TASKS_DIR, taskId, 'task-state.json');
+    if (await fs.pathExists(statePath)) {
+        const state = await fs.readJson(statePath).catch(() => ({}));
+        if (state.currentGate) return state.currentGate;
+    }
+
     const planDir = path.join(PROJECT_DIR, 'plan', taskId);
     if (!(await fs.pathExists(planDir))) return 1;
     if (await fs.pathExists(path.join(planDir, 'summary.md')))     return 5;
@@ -383,6 +399,29 @@ async function detectCurrentGate(taskId) {
     return 1;
 }
 
+async function generateMarkdownSummary(taskState) {
+    const lines = [];
+    lines.push(`# Task Summary: ${taskState.taskId}`);
+    lines.push(`**Title:** ${taskState.title}`);
+    lines.push(`**Status:** ${taskState.status}`);
+    lines.push(`**Current Gate:** ${taskState.currentGate} (${gateLabel(taskState.currentGate)})`);
+    lines.push(`**Updated At:** ${new Date().toLocaleString()}`);
+    lines.push(``);
+    lines.push(`## Gate History`);
+    lines.push(`| Gate | Status | Approved At |`);
+    lines.push(`|------|--------|-------------|`);
+    for (let i = 1; i <= 5; i++) {
+        const approvedAt = taskState.gateApprovals && taskState.gateApprovals[String(i)];
+        const status = approvedAt ? '✅ Approved' : (i === taskState.currentGate ? '⏳ In Progress' : '⚪ Pending');
+        const timeStr = approvedAt ? new Date(approvedAt).toLocaleString() : '-';
+        lines.push(`| Gate ${i} (${gateLabel(i)}) | ${status} | ${timeStr} |`);
+    }
+    lines.push(``);
+    lines.push(`---`);
+    lines.push(`*Auto-generated by aiflow task next*`);
+    return lines.join('\n');
+}
+
 function gateLabel(n) {
     const labels = {
         1: 'AI Analyze Requirement',

package/scripts/use.js

@@ -459,7 +459,8 @@ async function manualContext(prefillId = '') {
             { name: '✨ Feature', value: 'feature' },
             { name: '🔍 Investigation', value: 'investigation' },
             { name: '♻️  Refactor', value: 'refactor' },
-            { name: '📊 Impact Analysis', value: 'impact-analysis' }
+            { name: '📊 Impact Analysis', value: 'impact-analysis' },
+            { name: '📖 Documentation', value: 'documentation' }
         ],
         default: existing.taskType || undefined
     });
@@ -504,10 +505,25 @@ async function loadFromFile(filePath, options = {}) {
         context = JSON.parse(raw);
     } catch (_) {
         console.log(chalk.gray('  File is not JSON — auto-detecting task info from content...'));
-        context = buildContextFromPlainText(raw);
+        context = buildContextFromPlainText(raw, filePath);
     }
 
     context.mode = options.full ? 'full' : 'fast';
+
+    // Prompt for task type
+    context.taskType = await select({
+        message: 'Task type:',
+        choices: [
+            { name: '🐛 Bug Fix', value: 'bug-fix' },
+            { name: '✨ Feature', value: 'feature' },
+            { name: '🔍 Investigation', value: 'investigation' },
+            { name: '♻️  Refactor', value: 'refactor' },
+            { name: '📊 Impact Analysis', value: 'impact-analysis' },
+            { name: '📖 Documentation', value: 'documentation' }
+        ],
+        default: context.taskType || 'feature'
+    });
+
     await saveContext(context, options.save);
     printContextSummary(context);
     await suggestNextStep();
@@ -517,14 +533,29 @@ async function loadFromFile(filePath, options = {}) {
  * Build a minimal context object from arbitrary plain-text file content.
  * Tries to detect ticket ID (e.g. PROJ-33, APP-123) and a title from the first non-blank line.
  */
-function buildContextFromPlainText(text) {
+function buildContextFromPlainText(text, filePath = '') {
     // Detect ticket ID: first PROJ-123 style token anywhere in the text
     const idMatch = text.match(/\b([A-Z][A-Z0-9_]+-\d+)\b/);
-    const taskId = idMatch ? idMatch[1] : `TASK-${Date.now()}`;
 
-    // Title: first non-blank, non-id line (or first line of text)
+    let taskId;
+    if (idMatch) {
+        taskId = idMatch[1];
+    } else {
+        const fileNameOnly = filePath ? path.basename(filePath, path.extname(filePath)) : '';
+        const cleanWords = fileNameOnly.replace(/[^a-zA-Z0-9]/g, ' ')
+                                      .split(/\s+/)
+                                      .filter(Boolean)
+                                      .slice(0, 5)
+                                      .join('-')
+                                      .toUpperCase();
+        const prefix = cleanWords ? `TASK-${cleanWords}-` : 'TASK-';
+        taskId = `${prefix}${Date.now()}`;
+    }
+
+    // Title: use full filename if available, otherwise first non-blank line
+    const fullFileName = filePath ? path.basename(filePath) : '';
     const lines = text.split(/\r?\n/).map(l => l.trim()).filter(Boolean);
-    const titleLine = lines.find(l => l.length > 3) || taskId;
+    const titleLine = fullFileName || lines.find(l => l.length > 3) || taskId;
     const title = titleLine.substring(0, 120);
 
     // Task type detection from text