@bicorne/task-flow 0.2.0 → 0.2.1

package/dist/spec/sync-task-to-openspec.js

@@ -1,288 +1,257 @@
-"use strict";
-/**
- * sync-task-to-openspec.ts
- * Sync task execution status back to Spec
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.syncTaskToSpec = syncTaskToSpec;
-exports.main = main;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const config_1 = require("../lib/config");
-const state_1 = require("../lib/state");
-/**
- * Validate that a resolved path is within the project root (prevent path traversal)
- * @param resolvedPath - The resolved absolute path
- * @param projectRoot - The project root directory
- * @returns True if path is within project root
- */
-function isPathWithinProject(resolvedPath, projectRoot) {
-    const relativePath = path.relative(projectRoot, resolvedPath);
-    return !relativePath.startsWith('..') && !path.isAbsolute(relativePath);
+function e(t) {
+    return "function" != typeof WeakMap ? null : (e = function(e) {
+        return new WeakMap();
+    })(t);
 }
-function parseArgs(argv) {
-    const args = {};
-    for (let i = 2; i < argv.length; i += 1) {
-        const token = argv[i] || '';
-        if (!token.startsWith('--')) {
-            continue;
-        }
-        const key = token.slice(2);
-        const next = argv[i + 1] || '';
-        if (!next || next.startsWith('--')) {
-            args[key] = true;
-            continue;
-        }
-        args[key] = next;
-        i += 1;
+function t(t, n) {
+    var r, s, a;
+    if (!n && t && t.__esModule) return t;
+    if (null === t || "object" != typeof t && "function" != typeof t) return {
+        default: t
+    };
+    if ((r = e(n)) && r.has(t)) return r.get(t);
+    for(var l in s = {
+        __proto__: null
+    }, a = Object.defineProperty && Object.getOwnPropertyDescriptor, t)if ("default" !== l && Object.prototype.hasOwnProperty.call(t, l)) {
+        var o = a ? Object.getOwnPropertyDescriptor(t, l) : null;
+        o && (o.get || o.set) ? Object.defineProperty(s, l, o) : s[l] = t[l];
     }
-    return args;
+    return s.default = t, r && r.set(t, s), s;
 }
-function ensurePosix(p) {
-    return String(p || '').replace(/\\/g, '/');
+function n(e) {
+    return String(e || '').replace(/\\/g, '/');
 }
-function readJsonIfExists(filePath) {
-    if (!filePath || !fs.existsSync(filePath)) {
-        return null;
-    }
+function r(e) {
+    if (!e || !c.existsSync(e)) return null;
     try {
-        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    }
-    catch {
-        return null;
-    }
-}
-function readTextIfExists(filePath) {
-    if (!filePath || !fs.existsSync(filePath)) {
-        return '';
-    }
-    return fs.readFileSync(filePath, 'utf8');
-}
-function getTaskFilePath(config, taskId) {
-    return path.resolve(config.tasksDirAbs, `${taskId}.json`);
-}
-function readTaskJson(config, taskId) {
-    const taskPath = getTaskFilePath(config, taskId);
-    if (!fs.existsSync(taskPath)) {
+        return JSON.parse(c.readFileSync(e, 'utf8'));
+    } catch  {
         return null;
     }
-    return readJsonIfExists(taskPath);
 }
-function normalizeSnapshotValidations(snapshot) {
-    const results = Array.isArray(snapshot?.validationResults) ? snapshot.validationResults : [];
-    return results.map((item) => ({
-        name: item?.name || '',
-        status: item?.status || 'unknown',
-        detail: item?.detail || null,
-    }));
+function s(e, t) {
+    return p.resolve(e.tasksDirAbs, `${t}.json`);
 }
-function toExecutionStatus(state) {
-    if (state?.status === 'completed') {
-        return 'completed';
-    }
-    if (state?.lastGateBlockedReason) {
-        return 'blocked';
-    }
-    return state?.status || 'running';
-}
-function resolveReviewPath(config, taskJson) {
-    const report = taskJson?.metadata?.outputs?.report;
-    if (!report) {
-        return null;
-    }
-    return path.resolve(config.projectRoot, report);
-}
-function resolveSnapshotPath(config, state, taskJson) {
-    if (state?.currentSnapshot) {
-        return path.resolve(config.projectRoot, state.currentSnapshot);
-    }
-    const snapshot = taskJson?.metadata?.outputs?.snapshot;
-    if (!snapshot) {
-        return null;
-    }
-    return path.resolve(config.projectRoot, snapshot);
-}
-function parseReviewConclusion(content) {
-    const patterns = [
-        { regex: /^\s*(?:结论 |Conclusion)\s*:\s*PASS\b/m, result: 'PASS' },
-        { regex: /^\s*(?:结论 |Conclusion)\s*:\s*NEEDS_WORK\b/m, result: 'NEEDS_WORK' },
-        { regex: /^\s*(?:结论 |Conclusion)\s*:\s*FAIL\b/m, result: 'FAIL' },
-        { regex: /^##\s*结论\s*:\s*PASS\b/m, result: 'PASS' },
-        { regex: /^##\s*结论\s*:\s*NEEDS_WORK\b/m, result: 'NEEDS_WORK' },
-        { regex: /^##\s*结论\s*:\s*FAIL\b/m, result: 'FAIL' },
-        { regex: /^#\s*PASS\b/m, result: 'PASS' },
-        { regex: /^#\s*NEEDS_WORK\b/m, result: 'NEEDS_WORK' },
-        { regex: /^#\s*FAIL\b/m, result: 'FAIL' },
-        { regex: /\*\*结论\*\*\s*:\s*PASS\b/, result: 'PASS' },
-        { regex: /\*\*结论\*\*\s*:\s*NEEDS_WORK\b/, result: 'NEEDS_WORK' },
-        { regex: /\*\*结论\*\*\s*:\s*FAIL\b/, result: 'FAIL' },
-        { regex: /\*\*PASS\*\*/, result: 'PASS' },
-        { regex: /\*\*NEEDS_WORK\*\*/, result: 'NEEDS_WORK' },
-        { regex: /\*\*FAIL\*\*/, result: 'FAIL' },
-    ];
-    for (const { regex, result } of patterns) {
-        const match = content.match(regex);
-        if (match) {
-            return result;
-        }
-    }
-    return null;
-}
-function buildExecutionDocument(params) {
-    const { config, taskJson, state, taskId, spec } = params;
-    const snapshotPath = resolveSnapshotPath(config, state, taskJson);
-    const reportPath = resolveReviewPath(config, taskJson);
-    const snapshot = readJsonIfExists(snapshotPath);
-    const reportContent = readTextIfExists(reportPath);
-    const report = reportContent ? { conclusion: parseReviewConclusion(reportContent), validationMap: {} } : { conclusion: null, validationMap: {} };
-    const archivePath = path.resolve(config.archiveDirAbs, `${taskId}.json`);
-    const archive = readJsonIfExists(archivePath);
-    return {
-        change: spec.change,
-        taskId,
-        status: toExecutionStatus(state),
-        currentPhase: state?.currentPhase || null,
-        phaseCompleted: state?.phaseCompleted || null,
-        reviewConclusion: state?.reviewConclusion || report.conclusion || null,
-        currentSnapshot: state?.currentSnapshot || (snapshotPath ? ensurePosix(path.relative(config.projectRoot, snapshotPath)) : null),
-        updatedAt: state?.updatedAt || new Date().toISOString(),
-        startedAt: state?.startedAt || null,
-        archive: {
-            path: fs.existsSync(archivePath) ? ensurePosix(path.relative(config.projectRoot, archivePath)) : null,
-            eventCount: Array.isArray(archive?.events) ? archive.events.length : 0,
-            lastEvent: Array.isArray(archive?.events) && archive.events.length > 0 ? archive.events[archive.events.length - 1] : null,
-        },
-        lastGate: {
-            blockedAt: state?.lastGateBlockedAt || null,
-            reason: state?.lastGateBlockedReason || null,
-            phase: state?.lastGateBlockedPhase || null,
-            missingValidations: Array.isArray(state?.lastMissingValidations) ? state.lastMissingValidations : [],
-        },
-        taskPhases: {
-            planning: taskJson?.status || 'pending',
-            implementation: taskJson?.status || 'pending',
-            review: taskJson?.status || 'pending',
-        },
-        artifacts: {
-            task: ensurePosix(path.relative(config.projectRoot, getTaskFilePath(config, taskId))),
-            proposal: spec.proposal || null,
-            design: spec.design || null,
-            tasks: spec.tasks || null,
-            snapshot: snapshotPath ? ensurePosix(path.relative(config.projectRoot, snapshotPath)) : null,
-            review: reportPath ? ensurePosix(path.relative(config.projectRoot, reportPath)) : null,
-        },
-        planning: {
-            embedded: true,
-            summary: taskJson?.implementation?.notes || '',
-        },
-        validations: {
-            implementation: normalizeSnapshotValidations(snapshot),
-            review: Object.entries(report.validationMap || {}).map(([name, status]) => ({ name, status })),
-        },
-        mergeStrategy: taskJson?.metadata?.mergeStrategy || { type: 'squash', deleteBranch: true, deleteWorktree: true },
+function a(e = {}) {
+    var t;
+    let l, o, i = (0, d.loadConfig)({
+        cwd: e.cwd
+    }), u = (0, g.loadState)(i), S = e.taskId || u.currentTask;
+    if (!S) return {
+        skipped: !0,
+        reason: 'missing-task-id'
     };
-}
-function getMetadataSpec(taskJson) {
-    if (!taskJson?.metadata?.change) {
-        return null;
-    }
-    return {
-        change: taskJson.metadata.change,
-        proposal: taskJson.docs_to_read?.[0] || null,
-        design: taskJson.docs_to_read?.[1] || null,
-        tasks: taskJson.docs_to_read?.[2] || null,
-        manifest: taskJson.metadata.manifest || null,
-        execution: taskJson.metadata.execution || null,
-        version: 'v1',
+    let f = (l = s(i, S), c.existsSync(l) ? r(l) : null);
+    if (!f) return {
+        skipped: !0,
+        reason: 'missing-task-file'
     };
-}
-/**
- * Sync task to Spec
- */
-function syncTaskToSpec(options = {}) {
-    const config = (0, config_1.loadConfig)({ cwd: options.cwd });
-    const state = (0, state_1.loadState)(config);
-    const taskId = options.taskId || state.currentTask;
-    if (!taskId) {
-        return { skipped: true, reason: 'missing-task-id' };
-    }
-    const taskJson = readTaskJson(config, taskId);
-    if (!taskJson) {
-        return { skipped: true, reason: 'missing-task-file' };
-    }
-    const spec = getMetadataSpec(taskJson);
-    if (!spec?.change) {
-        return { skipped: true, reason: 'missing-spec-metadata' };
-    }
-    const executionTarget = spec.execution || ensurePosix(`spec/changes/${spec.change}/execution.json`);
-    const executionPath = path.resolve(config.projectRoot, executionTarget);
-    // Security: Validate execution path is within project root
-    if (!isPathWithinProject(executionPath, config.projectRoot)) {
-        console.error(`[SPEC-SYNC] Execution path escapes project root: ${executionTarget}`);
-        return { skipped: true, reason: 'invalid-execution-path' };
-    }
-    const executionDoc = buildExecutionDocument({ config, taskJson, state, taskId, spec });
-    fs.mkdirSync(path.dirname(executionPath), { recursive: true });
-    fs.writeFileSync(executionPath, JSON.stringify(executionDoc, null, 2), 'utf8');
-    return {
-        skipped: false,
-        taskId,
-        change: spec.change,
-        executionPath: ensurePosix(path.relative(config.projectRoot, executionPath)),
+    let m = f?.metadata?.change ? {
+        change: f.metadata.change,
+        proposal: f.docs_to_read?.[0] || null,
+        design: f.docs_to_read?.[1] || null,
+        tasks: f.docs_to_read?.[2] || null,
+        manifest: f.metadata.manifest || null,
+        execution: f.metadata.execution || null,
+        version: 'v1'
+    } : null;
+    if (!m?.change) return {
+        skipped: !0,
+        reason: 'missing-spec-metadata'
     };
-}
-/**
- * Main entry point
- */
-function main() {
-    const args = parseArgs(process.argv);
-    const result = syncTaskToSpec({
-        cwd: args.cwd,
-        taskId: args['task-id'],
+    let v = m.execution || n(`spec/changes/${m.change}/execution.json`), h = p.resolve(i.projectRoot, v);
+    if (t = i.projectRoot, (o = p.relative(t, h)).startsWith('..') || p.isAbsolute(o)) return console.error(`[SPEC-SYNC] Execution path escapes project root: ${v}`), {
+        skipped: !0,
+        reason: 'invalid-execution-path'
+    };
+    let A = function(e) {
+        let t, { config: a, taskJson: l, state: o, taskId: i, spec: u } = e, d = function(e, t, n) {
+            if (t?.currentSnapshot) return p.resolve(e.projectRoot, t.currentSnapshot);
+            let r = n?.metadata?.outputs?.snapshot;
+            return r ? p.resolve(e.projectRoot, r) : null;
+        }(a, o, l), g = (t = l?.metadata?.outputs?.report) ? p.resolve(a.projectRoot, t) : null, S = r(d), f = g && c.existsSync(g) ? c.readFileSync(g, 'utf8') : '', m = f ? {
+            conclusion: function(e) {
+                for (let { regex: t, result: n } of [
+                    {
+                        regex: /^\s*(?:结论 |Conclusion)\s*:\s*PASS\b/m,
+                        result: 'PASS'
+                    },
+                    {
+                        regex: /^\s*(?:结论 |Conclusion)\s*:\s*NEEDS_WORK\b/m,
+                        result: 'NEEDS_WORK'
+                    },
+                    {
+                        regex: /^\s*(?:结论 |Conclusion)\s*:\s*FAIL\b/m,
+                        result: 'FAIL'
+                    },
+                    {
+                        regex: /^##\s*结论\s*:\s*PASS\b/m,
+                        result: 'PASS'
+                    },
+                    {
+                        regex: /^##\s*结论\s*:\s*NEEDS_WORK\b/m,
+                        result: 'NEEDS_WORK'
+                    },
+                    {
+                        regex: /^##\s*结论\s*:\s*FAIL\b/m,
+                        result: 'FAIL'
+                    },
+                    {
+                        regex: /^#\s*PASS\b/m,
+                        result: 'PASS'
+                    },
+                    {
+                        regex: /^#\s*NEEDS_WORK\b/m,
+                        result: 'NEEDS_WORK'
+                    },
+                    {
+                        regex: /^#\s*FAIL\b/m,
+                        result: 'FAIL'
+                    },
+                    {
+                        regex: /\*\*结论\*\*\s*:\s*PASS\b/,
+                        result: 'PASS'
+                    },
+                    {
+                        regex: /\*\*结论\*\*\s*:\s*NEEDS_WORK\b/,
+                        result: 'NEEDS_WORK'
+                    },
+                    {
+                        regex: /\*\*结论\*\*\s*:\s*FAIL\b/,
+                        result: 'FAIL'
+                    },
+                    {
+                        regex: /\*\*PASS\*\*/,
+                        result: 'PASS'
+                    },
+                    {
+                        regex: /\*\*NEEDS_WORK\*\*/,
+                        result: 'NEEDS_WORK'
+                    },
+                    {
+                        regex: /\*\*FAIL\*\*/,
+                        result: 'FAIL'
+                    }
+                ])if (e.match(t)) return n;
+                return null;
+            }(f),
+            validationMap: {}
+        } : {
+            conclusion: null,
+            validationMap: {}
+        }, v = p.resolve(a.archiveDirAbs, `${i}.json`), h = r(v);
+        return {
+            change: u.change,
+            taskId: i,
+            status: o?.status === 'completed' ? 'completed' : o?.lastGateBlockedReason ? 'blocked' : o?.status || 'running',
+            currentPhase: o?.currentPhase || null,
+            phaseCompleted: o?.phaseCompleted || null,
+            reviewConclusion: o?.reviewConclusion || m.conclusion || null,
+            currentSnapshot: o?.currentSnapshot || (d ? n(p.relative(a.projectRoot, d)) : null),
+            updatedAt: o?.updatedAt || new Date().toISOString(),
+            startedAt: o?.startedAt || null,
+            archive: {
+                path: c.existsSync(v) ? n(p.relative(a.projectRoot, v)) : null,
+                eventCount: Array.isArray(h?.events) ? h.events.length : 0,
+                lastEvent: Array.isArray(h?.events) && h.events.length > 0 ? h.events[h.events.length - 1] : null
+            },
+            lastGate: {
+                blockedAt: o?.lastGateBlockedAt || null,
+                reason: o?.lastGateBlockedReason || null,
+                phase: o?.lastGateBlockedPhase || null,
+                missingValidations: Array.isArray(o?.lastMissingValidations) ? o.lastMissingValidations : []
+            },
+            taskPhases: {
+                planning: l?.status || 'pending',
+                implementation: l?.status || 'pending',
+                review: l?.status || 'pending'
+            },
+            artifacts: {
+                task: n(p.relative(a.projectRoot, s(a, i))),
+                proposal: u.proposal || null,
+                design: u.design || null,
+                tasks: u.tasks || null,
+                snapshot: d ? n(p.relative(a.projectRoot, d)) : null,
+                review: g ? n(p.relative(a.projectRoot, g)) : null
+            },
+            planning: {
+                embedded: !0,
+                summary: l?.implementation?.notes || ''
+            },
+            validations: {
+                implementation: (Array.isArray(S?.validationResults) ? S.validationResults : []).map((e)=>({
+                        name: e?.name || '',
+                        status: e?.status || 'unknown',
+                        detail: e?.detail || null
+                    })),
+                review: Object.entries(m.validationMap || {}).map(([e, t])=>({
+                        name: e,
+                        status: t
+                    }))
+            },
+            mergeStrategy: l?.metadata?.mergeStrategy || {
+                type: 'squash',
+                deleteBranch: !0,
+                deleteWorktree: !0
+            }
+        };
+    }({
+        config: i,
+        taskJson: f,
+        state: u,
+        taskId: S,
+        spec: m
     });
-    if (result.skipped) {
-        console.log(`[SPEC-SYNC] skipped: ${result.reason}`);
-        process.exit(0);
-    }
-    console.log(`[SPEC-SYNC] updated: ${result.executionPath}`);
-    process.exit(0);
+    return c.mkdirSync(p.dirname(h), {
+        recursive: !0
+    }), c.writeFileSync(h, JSON.stringify(A, null, 2), 'utf8'), {
+        skipped: !1,
+        taskId: S,
+        change: m.change,
+        executionPath: n(p.relative(i.projectRoot, h))
+    };
 }
-if (require.main === module) {
-    main();
+function l() {
+    let e = function(e) {
+        let t = {};
+        for(let n = 2; n < e.length; n += 1){
+            let r = e[n] || '';
+            if (!r.startsWith('--')) continue;
+            let s = r.slice(2), a = e[n + 1] || '';
+            if (!a || a.startsWith('--')) {
+                t[s] = !0;
+                continue;
+            }
+            t[s] = a, n += 1;
+        }
+        return t;
+    }(process.argv), t = a({
+        cwd: e.cwd,
+        taskId: e['task-id']
+    });
+    t.skipped && (console.log(`[SPEC-SYNC] skipped: ${t.reason}`), process.exit(0)), console.log(`[SPEC-SYNC] updated: ${t.executionPath}`), process.exit(0);
 }
-exports.default = {
-    syncTaskToSpec,
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+var o = exports, i = {
+    get default () {
+        return S;
+    },
+    get main () {
+        return l;
+    },
+    get syncTaskToSpec () {
+        return a;
+    }
+};
+for(var u in i)Object.defineProperty(o, u, {
+    enumerable: !0,
+    get: Object.getOwnPropertyDescriptor(i, u).get
+});
+let c = /*#__PURE__*/ t(require("fs")), p = /*#__PURE__*/ t(require("path")), d = require("../lib/config"), g = require("../lib/state");
+require.main === module && l();
+let S = {
+    syncTaskToSpec: a
 };

package/dist/types/ai-context.js

@@ -1,9 +1,4 @@
 "use strict";
-/**
- * types/ai-context.ts
- * AI 项目上下文协议定义
- *
- * AI 在调用 extract/design/tasks 命令前，先分析宿主项目并生成此结构，
- * 通过 --context-file 参数传入。CLI 命令会将其注入到生成的文档中。
- */
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bicorne/task-flow",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Harness Engineering tool for requirements analysis and task decomposition. AI-driven PRD generation, technical specs, and multi-phase task planning with zero-conflict parallel development via Git worktree.",
   "license": "MIT",
   "type": "commonjs",
@@ -41,6 +41,8 @@
   "devDependencies": {
     "@changesets/cli": "^2.27.0",
     "@eslint/js": "^9.0.0",
+    "@swc/cli": "^0.8.1",
+    "@swc/core": "^1.15.24",
     "@types/node": "^24.12.0",
     "@typescript-eslint/eslint-plugin": "8.58.0",
     "@typescript-eslint/parser": "8.58.0",
@@ -55,12 +57,12 @@
   "scripts": {
     "test": "node --test tests/**/*.test.js",
     "lint": "eslint src/",
-    "build": "tsc --project tsconfig.build.json",
-    "build:dev": "tsc",
-    "build:watch": "tsc --watch",
+    "build:dev": "swc src -d dist --strip-leading-paths --source-maps && tsc --project tsconfig.declarations.json",
+    "build:watch": "swc src -d dist --strip-leading-paths --watch",
+    "build:prod": "swc src -d dist --strip-leading-paths --config-file .swcrc.prod && tsc --project tsconfig.declarations.json",
     "typecheck": "tsc --noEmit",
     "changeset": "changeset",
-    "version": "changeset version",
-    "release": "pnpm build && changeset publish"
+    "consume": "changeset version",
+    "release": "pnpm typecheck && pnpm build:prod && changeset publish"
   }
 }

package/references/CLI-TUTORIAL.md

@@ -74,10 +74,7 @@ task-flow worktree --change my-feature --yes
 cd .worktrees/harness-feat-my-feature
 # 编码...
 
-# 步骤 10: 验证
-pnpm build && pnpm test && pnpm lint
-
-# 步骤 11: 合并
+# 步骤 10: 完成后合并
 cd ../..  # 回到主仓库
 task-flow merge my-feature
 ```
@@ -333,19 +330,16 @@ cd .worktrees/harness-feat-add-auth
 pnpm install
 # ... 编码 ...
 
-# 11. 验证
-pnpm build && pnpm test && pnpm lint
-
-# 12. 提交
+# 11. 完成后提交
 git add .
 git commit -m "feat: add user authentication"
 
-# 13. 回到主仓库并合并
+# 12. 回到主仓库并合并
 cd ../..
 task-flow merge add-auth --dry-run  # 先检查
 task-flow merge add-auth            # 实际合并
 
-# 14. 查看状态
+# 13. 查看状态
 task-flow status
 ```