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

package/scripts/checkpoint.js

@@ -1,46 +1,46 @@
-const fs = require('fs-extra');
-const path = require('path');
-const chalk = require('chalk');
-
-const PROJECT_DIR  = process.cwd();
-const AIFLOW_DIR   = path.join(PROJECT_DIR, '.aiflow');
-const CONTEXT_FILE = path.join(AIFLOW_DIR, 'context', 'current.json');
-
-const GATE_LABELS = { 1: 'Analyze', 2: 'Plan', 3: 'Code', 4: 'Review', 5: 'PR' };
-
-module.exports = async function checkpoint(options = {}) {
-    const { gate, step, tokens, ticket: ticketOpt } = options;
-
-    if (!gate || !step || tokens === undefined) {
-        console.log(chalk.yellow('Usage: aiflow checkpoint --gate <N> --step <name> --tokens <N>'));
-        console.log(chalk.gray('  Example: aiflow checkpoint --gate 3 --step "tests-written" --tokens 3200'));
-        return;
-    }
-
-    // Resolve ticket ID
-    let ticketId = ticketOpt;
-    if (!ticketId) {
-        const ctx = await fs.readJson(CONTEXT_FILE).catch(() => null);
-        ticketId = ctx && ctx.taskId ? ctx.taskId : 'unknown';
-    }
-
-    const taskDir = path.join(AIFLOW_DIR, 'tasks', ticketId);
-    await fs.ensureDir(taskDir);
-
-    const checkpointPath = path.join(taskDir, 'checkpoints.json');
-    const existing = (await fs.pathExists(checkpointPath))
-        ? await fs.readJson(checkpointPath).catch(() => ({ checkpoints: [] }))
-        : { checkpoints: [] };
-
-    const entry = {
-        gate:      parseInt(gate),
-        step,
-        tokens:    parseInt(tokens),
-        timestamp: new Date().toISOString(),
-    };
-    existing.checkpoints.push(entry);
-    await fs.writeJson(checkpointPath, existing, { spaces: 2 });
-
-    const label = GATE_LABELS[parseInt(gate)] || `Gate ${gate}`;
-    console.log(chalk.green(`✓ Checkpoint: Gate ${gate} (${label}) — ${step} — ~${parseInt(tokens).toLocaleString()} tokens`));
-};
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+const PROJECT_DIR  = process.cwd();
+const AIFLOW_DIR   = path.join(PROJECT_DIR, '.aiflow');
+const CONTEXT_FILE = path.join(AIFLOW_DIR, 'context', 'current.json');
+
+const GATE_LABELS = { 1: 'Analyze', 2: 'Plan', 3: 'Code', 4: 'Review', 5: 'PR' };
+
+module.exports = async function checkpoint(options = {}) {
+    const { gate, step, tokens, ticket: ticketOpt } = options;
+
+    if (!gate || !step || tokens === undefined) {
+        console.log(chalk.yellow('Usage: aiflow checkpoint --gate <N> --step <name> --tokens <N>'));
+        console.log(chalk.gray('  Example: aiflow checkpoint --gate 3 --step "tests-written" --tokens 3200'));
+        return;
+    }
+
+    // Resolve ticket ID
+    let ticketId = ticketOpt;
+    if (!ticketId) {
+        const ctx = await fs.readJson(CONTEXT_FILE).catch(() => null);
+        ticketId = ctx && ctx.taskId ? ctx.taskId : 'unknown';
+    }
+
+    const taskDir = path.join(AIFLOW_DIR, 'tasks', ticketId);
+    await fs.ensureDir(taskDir);
+
+    const checkpointPath = path.join(taskDir, 'checkpoints.json');
+    const existing = (await fs.pathExists(checkpointPath))
+        ? await fs.readJson(checkpointPath).catch(() => ({ checkpoints: [] }))
+        : { checkpoints: [] };
+
+    const entry = {
+        gate:      parseInt(gate),
+        step,
+        tokens:    parseInt(tokens),
+        timestamp: new Date().toISOString(),
+    };
+    existing.checkpoints.push(entry);
+    await fs.writeJson(checkpointPath, existing, { spaces: 2 });
+
+    const label = GATE_LABELS[parseInt(gate)] || `Gate ${gate}`;
+    console.log(chalk.green(`✓ Checkpoint: Gate ${gate} (${label}) — ${step} — ~${parseInt(tokens).toLocaleString()} tokens`));
+};

package/scripts/gitnexus-worker.js

@@ -1,94 +1,94 @@
-#!/usr/bin/env node
-/**
- * Background worker: runs `npx gitnexus analyze` and writes result to
- * .aiflow/gitnexus-status.json so session-start.js / use.js can notify the developer.
- *
- * Spawned as a detached process by init.js — never run directly.
- * Usage: node gitnexus-worker.js <projectDir>
- */
-
-const { spawn, execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-function commandExists(cmd) {
-    try {
-        const isWin = process.platform === 'win32';
-        const checkCmd = isWin ? `where ${cmd}` : `which ${cmd}`;
-        execSync(checkCmd, { stdio: 'ignore' });
-        return true;
-    } catch (_) {
-        return false;
-    }
-}
-
-const projectDir = process.argv[2];
-if (!projectDir) process.exit(1);
-
-const statusPath = path.join(projectDir, '.aiflow', 'gitnexus-status.json');
-const logPath    = path.join(projectDir, '.aiflow', 'gitnexus-analyze.log');
-
-// Preserve startedAt written by init.js
-let startedAt = new Date().toISOString();
-try {
-    if (fs.existsSync(statusPath)) {
-        const existing = JSON.parse(fs.readFileSync(statusPath, 'utf-8'));
-        if (existing.startedAt) startedAt = existing.startedAt;
-    }
-} catch (_) {}
-
-// gitnexus requires Node >=20
-const nodeMajor = parseInt(process.version.slice(1).split('.')[0], 10);
-if (nodeMajor < 20) {
-    try {
-        fs.writeFileSync(statusPath, JSON.stringify({
-            status: 'error',
-            startedAt,
-            completedAt: new Date().toISOString(),
-            error: `Node.js version >=20 required (current: ${process.version})`,
-        }, null, 2));
-    } catch (_) {}
-    process.exit(0);
-}
-
-// Status path and log path already defined above
-
-const logStream = fs.createWriteStream(logPath, { flags: 'w' });
-
-// On Windows use shell:true — avoids EINVAL when spawning .cmd scripts
-const isWin = process.platform === 'win32';
-
-const hasGlobalGitNexus = commandExists('gitnexus');
-const cmd = hasGlobalGitNexus ? 'gitnexus' : 'npx';
-const args = hasGlobalGitNexus ? ['analyze'] : ['-y', 'gitnexus@latest', 'analyze'];
-
-const child = spawn(cmd, args, {
-    cwd: projectDir,
-    shell: isWin,
-    windowsHide: true,
-    stdio: ['ignore', 'pipe', 'pipe'],
-});
-
-child.stdout.pipe(logStream);
-child.stderr.pipe(logStream);
-
-child.on('close', (code) => {
-    const status = code === 0
-        ? { status: 'done',  startedAt, completedAt: new Date().toISOString() }
-        : { status: 'error', startedAt, completedAt: new Date().toISOString(), exitCode: code };
-    try {
-        fs.writeFileSync(statusPath, JSON.stringify(status, null, 2));
-    } catch (_) {}
-});
-
-child.on('error', (err) => {
-    try {
-        fs.writeFileSync(statusPath, JSON.stringify({
-            status: 'error',
-            startedAt,
-            completedAt: new Date().toISOString(),
-            exitCode: null,
-            error: err.message,
-        }, null, 2));
-    } catch (_) {}
-});
+#!/usr/bin/env node
+/**
+ * Background worker: runs `npx gitnexus analyze` and writes result to
+ * .aiflow/gitnexus-status.json so session-start.js / use.js can notify the developer.
+ *
+ * Spawned as a detached process by init.js — never run directly.
+ * Usage: node gitnexus-worker.js <projectDir>
+ */
+
+const { spawn, execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+function commandExists(cmd) {
+    try {
+        const isWin = process.platform === 'win32';
+        const checkCmd = isWin ? `where ${cmd}` : `which ${cmd}`;
+        execSync(checkCmd, { stdio: 'ignore' });
+        return true;
+    } catch (_) {
+        return false;
+    }
+}
+
+const projectDir = process.argv[2];
+if (!projectDir) process.exit(1);
+
+const statusPath = path.join(projectDir, '.aiflow', 'gitnexus-status.json');
+const logPath    = path.join(projectDir, '.aiflow', 'gitnexus-analyze.log');
+
+// Preserve startedAt written by init.js
+let startedAt = new Date().toISOString();
+try {
+    if (fs.existsSync(statusPath)) {
+        const existing = JSON.parse(fs.readFileSync(statusPath, 'utf-8'));
+        if (existing.startedAt) startedAt = existing.startedAt;
+    }
+} catch (_) {}
+
+// gitnexus requires Node >=20
+const nodeMajor = parseInt(process.version.slice(1).split('.')[0], 10);
+if (nodeMajor < 20) {
+    try {
+        fs.writeFileSync(statusPath, JSON.stringify({
+            status: 'error',
+            startedAt,
+            completedAt: new Date().toISOString(),
+            error: `Node.js version >=20 required (current: ${process.version})`,
+        }, null, 2));
+    } catch (_) {}
+    process.exit(0);
+}
+
+// Status path and log path already defined above
+
+const logStream = fs.createWriteStream(logPath, { flags: 'w' });
+
+// On Windows use shell:true — avoids EINVAL when spawning .cmd scripts
+const isWin = process.platform === 'win32';
+
+const hasGlobalGitNexus = commandExists('gitnexus');
+const cmd = hasGlobalGitNexus ? 'gitnexus' : 'npx';
+const args = hasGlobalGitNexus ? ['analyze'] : ['-y', 'gitnexus@latest', 'analyze'];
+
+const child = spawn(cmd, args, {
+    cwd: projectDir,
+    shell: isWin,
+    windowsHide: true,
+    stdio: ['ignore', 'pipe', 'pipe'],
+});
+
+child.stdout.pipe(logStream);
+child.stderr.pipe(logStream);
+
+child.on('close', (code) => {
+    const status = code === 0
+        ? { status: 'done',  startedAt, completedAt: new Date().toISOString() }
+        : { status: 'error', startedAt, completedAt: new Date().toISOString(), exitCode: code };
+    try {
+        fs.writeFileSync(statusPath, JSON.stringify(status, null, 2));
+    } catch (_) {}
+});
+
+child.on('error', (err) => {
+    try {
+        fs.writeFileSync(statusPath, JSON.stringify({
+            status: 'error',
+            startedAt,
+            completedAt: new Date().toISOString(),
+            exitCode: null,
+            error: err.message,
+        }, null, 2));
+    } catch (_) {}
+});

package/scripts/hooks/block-git-write.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+/**
+ * PreToolUse hook for ai-flow-kit
+ *
+ * Hard-blocks AI from running git-write operations (commit/add/push/tag) via the
+ * Bash tool. The developer always controls commits manually in their own terminal.
+ *
+ * Stdin payload (from Claude Code):
+ *   { tool_name: "Bash", tool_input: { command: "..." }, ... }
+ *
+ * Exit codes:
+ *   0 — allow (stdout empty)
+ *   2 — block (stderr message is fed back to Claude as feedback)
+ *
+ * Override (for the kit's own maintenance scripts):
+ *   export AIFLOW_ALLOW_GIT_WRITE=1
+ */
+
+let raw = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (chunk) => { raw += chunk; });
+process.stdin.on('end', () => {
+    try {
+        if (process.env.AIFLOW_ALLOW_GIT_WRITE === '1') process.exit(0);
+
+        const payload = raw ? JSON.parse(raw) : {};
+        if (payload.tool_name !== 'Bash') process.exit(0);
+
+        const command = (payload.tool_input && payload.tool_input.command) || '';
+        if (!command) process.exit(0);
+
+        // Match `git <subcommand>` where subcommand is a write operation.
+        // Tolerates leading args (e.g. `git -C path commit`, `git --no-pager add`).
+        // Captures occurrences inside compound shells: `&&`, `||`, `;`, `|`, `$(...)`, backticks, newline.
+        const BLOCK_RE = /(^|[\s;&|`(){}])git(\s+-[^\s]+)*\s+(commit|add|push|tag|reset|rebase|revert|cherry-pick|am|merge)\b/i;
+        const match = command.match(BLOCK_RE);
+        if (!match) process.exit(0);
+
+        const verb = match[3].toLowerCase();
+        process.stderr.write(
+            `[aiflow] BLOCKED: \`git ${verb}\` is not allowed for AI.\n` +
+            `Reason: ai-flow-kit forbids AI-driven commits/pushes. The developer manages git state manually.\n` +
+            `If this is a legitimate maintenance task (running the kit's own CI), set AIFLOW_ALLOW_GIT_WRITE=1 in the environment.\n` +
+            `Otherwise, finish the task without committing; the developer will run \`git ${verb}\` themselves at Gate 5.\n`
+        );
+        process.exit(2);
+    } catch (err) {
+        // On parsing error, fail open (don't block) but log to stderr for visibility.
+        process.stderr.write(`[aiflow] block-git-write hook error: ${err.message}\n`);
+        process.exit(0);
+    }
+});

package/scripts/hooks/session-stop.js

@@ -1,55 +1,55 @@
-#!/usr/bin/env node
-/**
- * SessionStop hook for ai-flow-kit
- * Reads checkpoints.json for the active task and prints a token usage summary.
- */
-
-const fs = require('fs');
-const path = require('path');
-const { record } = require('../telemetry/record');
-
-record('session.stop');
-
-const projectRoot  = path.resolve(__dirname, '..', '..');
-const contextFile  = path.join(projectRoot, '.aiflow', 'context', 'current.json');
-const tasksDir     = path.join(projectRoot, '.aiflow', 'tasks');
-
-const GATE_LABELS = { 1: 'Analyze', 2: 'Plan', 3: 'Code', 4: 'Review', 5: 'PR' };
-
-try {
-    if (!fs.existsSync(contextFile)) process.exit(0);
-    const ctx = JSON.parse(fs.readFileSync(contextFile, 'utf-8'));
-    const ticketId = ctx && ctx.taskId;
-    if (!ticketId) process.exit(0);
-
-    const checkpointPath = path.join(tasksDir, ticketId, 'checkpoints.json');
-    if (!fs.existsSync(checkpointPath)) process.exit(0);
-
-    const data = JSON.parse(fs.readFileSync(checkpointPath, 'utf-8'));
-    const checkpoints = data.checkpoints || [];
-    if (checkpoints.length === 0) process.exit(0);
-
-    // Aggregate latest token value per gate
-    const gateTokens = {};
-    for (const cp of checkpoints) {
-        const g = cp.gate;
-        if (!gateTokens[g] || cp.tokens > gateTokens[g]) {
-            gateTokens[g] = cp.tokens;
-        }
-    }
-
-    const gates = Object.keys(gateTokens).sort();
-    const total  = gates.reduce((sum, g) => sum + gateTokens[g], 0);
-
-    process.stderr.write('\n[aiflow] Token usage this session:\n');
-    for (const g of gates) {
-        const label   = GATE_LABELS[parseInt(g)] || `Gate ${g}`;
-        const t       = gateTokens[g];
-        const bar     = '█'.repeat(Math.round((t / total) * 20)).padEnd(20, '░');
-        const pct     = Math.round((t / total) * 100);
-        process.stderr.write(`[aiflow]   Gate ${g}  ${label.padEnd(8)}  ~${t.toLocaleString().padStart(6)}  ${bar}  ${pct}%\n`);
-    }
-    process.stderr.write(`[aiflow]   Total estimated: ~${total.toLocaleString()} tokens\n\n`);
-} catch (_) {}
-
-process.exit(0);
+#!/usr/bin/env node
+/**
+ * SessionStop hook for ai-flow-kit
+ * Reads checkpoints.json for the active task and prints a token usage summary.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { record } = require('../telemetry/record');
+
+record('session.stop');
+
+const projectRoot  = path.resolve(__dirname, '..', '..');
+const contextFile  = path.join(projectRoot, '.aiflow', 'context', 'current.json');
+const tasksDir     = path.join(projectRoot, '.aiflow', 'tasks');
+
+const GATE_LABELS = { 1: 'Analyze', 2: 'Plan', 3: 'Code', 4: 'Review', 5: 'PR' };
+
+try {
+    if (!fs.existsSync(contextFile)) process.exit(0);
+    const ctx = JSON.parse(fs.readFileSync(contextFile, 'utf-8'));
+    const ticketId = ctx && ctx.taskId;
+    if (!ticketId) process.exit(0);
+
+    const checkpointPath = path.join(tasksDir, ticketId, 'checkpoints.json');
+    if (!fs.existsSync(checkpointPath)) process.exit(0);
+
+    const data = JSON.parse(fs.readFileSync(checkpointPath, 'utf-8'));
+    const checkpoints = data.checkpoints || [];
+    if (checkpoints.length === 0) process.exit(0);
+
+    // Aggregate latest token value per gate
+    const gateTokens = {};
+    for (const cp of checkpoints) {
+        const g = cp.gate;
+        if (!gateTokens[g] || cp.tokens > gateTokens[g]) {
+            gateTokens[g] = cp.tokens;
+        }
+    }
+
+    const gates = Object.keys(gateTokens).sort();
+    const total  = gates.reduce((sum, g) => sum + gateTokens[g], 0);
+
+    process.stderr.write('\n[aiflow] Token usage this session:\n');
+    for (const g of gates) {
+        const label   = GATE_LABELS[parseInt(g)] || `Gate ${g}`;
+        const t       = gateTokens[g];
+        const bar     = '█'.repeat(Math.round((t / total) * 20)).padEnd(20, '░');
+        const pct     = Math.round((t / total) * 100);
+        process.stderr.write(`[aiflow]   Gate ${g}  ${label.padEnd(8)}  ~${t.toLocaleString().padStart(6)}  ${bar}  ${pct}%\n`);
+    }
+    process.stderr.write(`[aiflow]   Total estimated: ~${total.toLocaleString()} tokens\n\n`);
+} catch (_) {}
+
+process.exit(0);

package/scripts/init.js

@@ -24,7 +24,7 @@ function commandExists(cmd) {
 // Map framework → language family for picking the right rules
 const FRAMEWORK_LANGUAGE = {
     'laravel':      'php',
-    'php-plain':    'php',
+    'php':          'php',
     'spring-boot':  'java',
     'reactjs':      'javascript',
     'nextjs':       'javascript',
@@ -80,7 +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';
+        return 'php';
     }
     // Python
     if (await fs.pathExists(path.join(projectDir, 'manage.py'))) return 'python-django';
@@ -89,7 +89,9 @@ async function detectFramework(projectDir) {
         const reqs = (await fs.readFile(reqPath, 'utf-8').catch(() => '')).toLowerCase();
         if (reqs.includes('fastapi')) return 'python-fastapi';
         if (reqs.includes('django'))  return 'python-django';
+        return 'python';
     }
+    if (await fs.pathExists(path.join(projectDir, 'pyproject.toml'))) return 'python';
     return null;
 }
 
@@ -99,9 +101,10 @@ 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: 'PHP',                value: 'php' },
     { name: 'NestJS',             value: 'nestjs' },
     { name: 'Node.js / Express',  value: 'nodejs-express' },
+    { name: 'Python',             value: 'python' },
     { name: 'Python Django',      value: 'python-django' },
     { name: 'Python FastAPI',     value: 'python-fastapi' },
 ];
@@ -182,6 +185,10 @@ async function setupSuperpowersHook(_projectDir, claudeDir) {
     const hookStopDest = path.join(hooksDir, 'session-stop.js');
     await fs.copy(hookStopSrc, hookStopDest, { overwrite: true });
 
+    const hookBlockGitSrc  = path.join(PKG_DIR, 'scripts', 'hooks', 'block-git-write.js');
+    const hookBlockGitDest = path.join(hooksDir, 'block-git-write.js');
+    await fs.copy(hookBlockGitSrc, hookBlockGitDest, { overwrite: true });
+
     const settingsFile = path.join(claudeDir, 'settings.json');
     let settings = {};
     if (await fs.pathExists(settingsFile)) {
@@ -191,6 +198,7 @@ async function setupSuperpowersHook(_projectDir, claudeDir) {
     if (!settings.hooks) settings.hooks = {};
     if (!settings.hooks.SessionStart) settings.hooks.SessionStart = [];
     if (!settings.hooks.SessionStop) settings.hooks.SessionStop = [];
+    if (!settings.hooks.PreToolUse) settings.hooks.PreToolUse = [];
 
     settings.hooks.SessionStart = settings.hooks.SessionStart.filter(
         h => !(h._aiflowKit)
@@ -218,8 +226,22 @@ async function setupSuperpowersHook(_projectDir, claudeDir) {
         ]
     });
 
+    settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(
+        h => !(h._aiflowKitBlockGitWrite)
+    );
+    settings.hooks.PreToolUse.push({
+        _aiflowKitBlockGitWrite: true,
+        matcher: 'Bash',
+        hooks: [
+            {
+                type: 'command',
+                command: `node "${hookBlockGitDest.replace(/\\/g, '/')}"`,
+            }
+        ]
+    });
+
     await fs.writeJson(settingsFile, settings, { spaces: 2 });
-    console.log(chalk.green(`✓ Superpowers hooks (SessionStart, SessionStop) configured`));
+    console.log(chalk.green(`✓ Superpowers hooks (SessionStart, SessionStop, PreToolUse:block-git-write) configured`));
 }
 
 async function verifySuperpowersSkills(versionDir) {
@@ -468,7 +490,7 @@ async function setupAdapter(projectDir, adapter) {
     }
     globalData.mcp = { ...(globalData.mcp || {}), ...credentials };
     await fs.writeJson(GLOBAL_CREDENTIALS_PATH, globalData, { spaces: 2 });
-    await ensureCredentialsGitignored(projectDir);
+    await ensureAiflowGitignored(projectDir);
 
     console.log(chalk.green(`✓ MCP configuration saved (global + local + credentials).`));
 }

package/scripts/task.js

@@ -178,6 +178,9 @@ async function resumeTask(taskId) {
     await fs.ensureDir(CONTEXT_DIR);
     await fs.writeJson(CURRENT_FILE, ctx, { spaces: 2 });
 
+    // Deactivate any other tasks before marking this one active
+    await deactivateOtherTasks(taskId);
+
     // Mark as active
     const now = new Date().toISOString();
     taskState.status    = 'active';
@@ -369,6 +372,21 @@ async function nextGate(taskId) {
 // Internal helpers
 // ──────────────────────────────────────────────────────────────
 
+async function deactivateOtherTasks(exceptTaskId) {
+    if (!(await fs.pathExists(TASKS_DIR))) return;
+    const entries = await fs.readdir(TASKS_DIR, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name === exceptTaskId) continue;
+        const statePath = path.join(TASKS_DIR, entry.name, 'task-state.json');
+        if (!(await fs.pathExists(statePath))) continue;
+        const state = await fs.readJson(statePath).catch(() => null);
+        if (state && state.status === 'active') {
+            const now = new Date().toISOString();
+            await fs.writeJson(statePath, { ...state, status: 'pending', updatedAt: now, pausedAt: now }, { spaces: 2 });
+        }
+    }
+}
+
 async function loadAllTaskStates() {
     if (!(await fs.pathExists(TASKS_DIR))) return [];
     const entries = await fs.readdir(TASKS_DIR, { withFileTypes: true });
@@ -467,6 +485,9 @@ module.exports.createOrActivateTaskState = async function createOrActivateTaskSt
     // Detect current gate
     const currentGate = await detectCurrentGate(taskId);
 
+    // Deactivate any other tasks before marking this one active
+    await deactivateOtherTasks(taskId);
+
     const existing  = (await fs.pathExists(statePath)) ? await fs.readJson(statePath).catch(() => ({})) : {};
     const now = new Date().toISOString();
     const taskState = {