@planu/cli 4.9.0 → 4.10.0

package/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [4.10.0] - 2026-07-01
+
+### Features
+- feat(SPEC-1100): add reliable feedback sync
+
+### Bug Fixes
+- fix(SPEC-1102): honor release preflight test skip
+- fix(SPEC-1101): harden validate runtime and status
+
+### Chores
+- chore(deps): refresh direct dependencies
+
+
 ## [4.9.0] - 2026-06-30
 
 ### Features

package/dist/config/license-plans.json

@@ -92,6 +92,7 @@
     "export_spec",
     "expose_spec_as_prompt",
     "facilitate",
+    "feedback_status",
     "gc_data_projects",
     "generate_api_client",
     "generate_attestation",
@@ -163,6 +164,7 @@
     "render_spec_for_provider",
     "repair_frontmatter_drift",
     "request_changes",
+    "resolve_feedback",
     "reverse_engineer",
     "rewrite_criteria_ears",
     "run_mutation_hints",
@@ -189,13 +191,16 @@
     "suggest_token_optimizer",
     "suggest_tooling",
     "summarize_spec",
+    "submit_feedback",
     "sync_ai_configs",
+    "sync_feedback",
     "sync_spec_state",
     "tdd_scaffold",
     "tdd_status",
     "telemetry_health",
     "token_optimizer_status",
     "transform_code",
+    "triage_feedback",
     "triage_request",
     "type_safety_gate",
     "unregister_project_path",

package/dist/config/registries/hosts/codex.json

@@ -294,6 +294,8 @@
     "submit_feedback",
     "triage_feedback",
     "resolve_feedback",
+    "sync_feedback",
+    "feedback_status",
     "delete_spec",
     "delete_project",
     "delete_pattern",
@@ -373,10 +375,7 @@
     "analyze_performance_impact",
     "recommend_model"
   ],
-  "unsupportedTools": [
-    "challenge_spec",
-    "red_team"
-  ],
+  "unsupportedTools": ["challenge_spec", "red_team"],
   "restrictedTools": {
     "challenge_spec": "Requires interactive UI — use planu_facilitate instead",
     "approve_spec": "Requires reviewer token — use planu_facilitate instead"

package/dist/engine/evidence-index/index-builder.js

@@ -37,16 +37,16 @@ async function collectEvidence(args) {
             records.push(record('scenario', row.scenario, 'valid', 'traceability-matrix'));
         }
         for (const test of row.testEvidence ?? []) {
-            records.push(await pathRecord('test', test, 'traceability-matrix', args));
+            records.push(await pathRecord('test', test, 'traceability-matrix', args, 'testEvidence'));
         }
         for (const contract of row.contractEvidence ?? []) {
-            records.push(await pathRecord('contract', contract, 'traceability-matrix', args));
+            records.push(await pathRecord('contract', contract, 'traceability-matrix', args, 'contractEvidence'));
         }
         if (row.manualEvidence) {
             records.push(record('manual', row.manualEvidence, 'valid', 'traceability-matrix'));
         }
         for (const changedFile of row.changedFiles) {
-            records.push(await pathRecord('changed-file', changedFile, 'traceability-matrix', args));
+            records.push(await pathRecord('changed-file', changedFile, 'traceability-matrix', args, 'changedFiles'));
         }
         if (row.validationEvidence) {
             records.push(validationRecord(row.validationEvidence));
@@ -57,7 +57,7 @@ async function collectEvidence(args) {
     }
     for (const validation of args.contractValidations) {
         if (validation.reportPath) {
-            records.push(await pathRecord('contract', validation.reportPath, `contract-validation:${validation.kind}`, args));
+            records.push(await pathRecord('contract', validation.reportPath, `contract-validation:${validation.kind}`, args, 'contractValidation.reportPath'));
         }
         if (validation.summary) {
             records.push({
@@ -95,36 +95,62 @@ function parseValidationEvidence(value) {
         return { command: value };
     }
 }
-async function pathRecord(kind, value, source, args) {
-    const safe = resolveSafeProjectPath(value, args.projectPath);
+async function pathRecord(kind, value, source, args, fieldName) {
+    const safe = resolveSafeProjectPath(value, args.projectPath, fieldName);
     if (!safe.ok) {
         args.diagnostics.push(`${value}: ${safe.reason}`);
         return record(kind, value, 'invalid', source, safe.reason);
     }
     if (!args.projectPath) {
-        return record(kind, value, 'missing', source, 'projectPath unavailable');
+        return record(kind, value, 'missing', source, evidencePathReason(fieldName, 'projectPath unavailable'));
     }
     const exists = await stat(safe.path)
         .then(() => true)
         .catch(() => false);
-    return record(kind, value, exists ? 'valid' : 'stale', source, exists ? undefined : 'file missing');
+    const missingReason = evidencePathReason(fieldName, `Missing path: ${value}`);
+    return record(kind, value, exists ? 'valid' : 'stale', source, exists ? undefined : missingReason);
 }
-function resolveSafeProjectPath(value, projectPath) {
+function resolveSafeProjectPath(value, projectPath, fieldName) {
     if (value.trim().length === 0) {
-        return { ok: false, reason: 'empty evidence path' };
+        return { ok: false, reason: evidencePathReason(fieldName, 'Empty path.') };
+    }
+    if (looksLikeShellCommand(value)) {
+        return { ok: false, reason: evidencePathReason(fieldName, 'Commands are not valid paths.') };
+    }
+    if (looksLikeGlob(value)) {
+        return { ok: false, reason: evidencePathReason(fieldName, 'Globs are not valid paths.') };
     }
     if (isAbsolute(value)) {
-        return { ok: false, reason: 'absolute evidence paths are not allowed' };
+        return { ok: false, reason: evidencePathReason(fieldName, 'Absolute paths are not allowed.') };
     }
     const normalized = normalize(value);
     if (normalized.startsWith('..') || normalized.includes('/../')) {
-        return { ok: false, reason: 'path traversal is not allowed' };
+        return { ok: false, reason: evidencePathReason(fieldName, 'Path traversal is not allowed.') };
     }
     if (!projectPath) {
         return { ok: true, path: normalized };
     }
     return { ok: true, path: join(projectPath, normalized) };
 }
+function evidencePathReason(fieldName, detail) {
+    if (fieldName === 'testEvidence') {
+        return `testEvidence must contain existing file paths only; put command output in validationEvidence. ${detail}`;
+    }
+    if (fieldName === 'changedFiles') {
+        return `changedFiles must contain existing repository-relative paths only; no globs or commands. ${detail}`;
+    }
+    return `Evidence path must be an existing repository-relative path. ${detail}`;
+}
+function looksLikeShellCommand(value) {
+    const trimmed = value.trim();
+    if (/\s/.test(trimmed) && !/\.[A-Za-z0-9]+$/.test(trimmed)) {
+        return true;
+    }
+    return /^(?:pnpm|npm|yarn|bun|npx|node|tsx|tsc|vitest|jest|git|bash|sh)\b/.test(trimmed);
+}
+function looksLikeGlob(value) {
+    return /[*?[\]{}]/.test(value);
+}
 function record(kind, value, status, source, reason) {
     return { kind, value, status, source, ...(reason ? { reason } : {}) };
 }

package/dist/storage/feedback-remote.d.ts

@@ -1,5 +1,9 @@
-import type { RemoteFeedbackPayload } from '../types/feedback.js';
+import type { FeedbackRemoteResult, RemoteFeedbackPayload } from '../types/feedback.js';
+export declare const DEFAULT_FEEDBACK_API = "https://canusqigtzldstnjddio.supabase.co/functions/v1/license-api/feedback";
 export type { RemoteFeedbackPayload };
+export declare function resolveFeedbackEndpoint(endpoint?: string): string;
+export declare function sanitizeRemoteFeedbackPayload(payload: RemoteFeedbackPayload): RemoteFeedbackPayload;
+export declare function deliverFeedbackRemote(payload: RemoteFeedbackPayload, endpoint?: string): Promise<FeedbackRemoteResult>;
 /**
  * Send feedback to central Supabase store (fire-and-forget).
  * Never throws. Returns true if sent successfully, false otherwise.

package/dist/storage/feedback-remote.js

@@ -1,27 +1,86 @@
 // storage/feedback-remote.ts — Remote feedback relay to Supabase (fire-and-forget)
 // No PII is ever sent: no project paths, no user names, no emails.
-const FEEDBACK_API = 'https://canusqigtzldstnjddio.supabase.co/functions/v1/license-api/feedback';
-/**
- * Send feedback to central Supabase store (fire-and-forget).
- * Never throws. Returns true if sent successfully, false otherwise.
- */
-export async function sendFeedbackRemote(payload) {
+export const DEFAULT_FEEDBACK_API = 'https://canusqigtzldstnjddio.supabase.co/functions/v1/license-api/feedback';
+export function resolveFeedbackEndpoint(endpoint) {
+    return endpoint ?? process.env.PLANU_FEEDBACK_ENDPOINT ?? DEFAULT_FEEDBACK_API;
+}
+function redactSensitiveText(value) {
+    return value
+        .replace(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, '[redacted-email]')
+        .replace(/(?:\/Users|\/home|\/var|\/tmp|[A-Za-z]:\\)[^\s)'"`]+/g, '[redacted-path]')
+        .replace(/```[\s\S]*?```/g, '[redacted-code-block]')
+        .replace(/\b(?:const|let|var|function|class|import|export)\s+[^\n]+/g, '[redacted-code]');
+}
+export function sanitizeRemoteFeedbackPayload(payload) {
+    return {
+        ...payload,
+        title: redactSensitiveText(payload.title),
+        description: redactSensitiveText(payload.description),
+        ...(payload.stack !== undefined ? { stack: redactSensitiveText(payload.stack) } : {}),
+    };
+}
+export async function deliverFeedbackRemote(payload, endpoint) {
+    const resolvedEndpoint = resolveFeedbackEndpoint(endpoint);
+    let url;
     try {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => {
-            controller.abort();
-        }, 5000); // 5s timeout
-        const res = await fetch(FEEDBACK_API, {
+        url = new URL(resolvedEndpoint);
+    }
+    catch {
+        return {
+            ok: false,
+            status: 'skipped',
+            endpoint: resolvedEndpoint,
+            error: 'Invalid feedback endpoint URL.',
+        };
+    }
+    if (url.protocol !== 'https:' && url.hostname !== 'localhost' && url.hostname !== '127.0.0.1') {
+        return {
+            ok: false,
+            status: 'skipped',
+            endpoint: resolvedEndpoint,
+            error: 'Feedback endpoint must use HTTPS.',
+        };
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+        controller.abort();
+    }, 5000);
+    try {
+        const res = await fetch(resolvedEndpoint, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(payload),
+            body: JSON.stringify(sanitizeRemoteFeedbackPayload(payload)),
             signal: controller.signal,
         });
-        clearTimeout(timeout);
-        return res.ok;
+        if (res.ok) {
+            return { ok: true, status: 'synced', endpoint: resolvedEndpoint };
+        }
+        return {
+            ok: false,
+            status: 'failed',
+            endpoint: resolvedEndpoint,
+            error: `Remote feedback endpoint returned HTTP ${res.status}.`,
+        };
     }
-    catch {
-        return false; // Network error, timeout, etc. — silently fail
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            ok: false,
+            status: 'failed',
+            endpoint: resolvedEndpoint,
+            error: message || 'Remote feedback request failed.',
+        };
     }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Send feedback to central Supabase store (fire-and-forget).
+ * Never throws. Returns true if sent successfully, false otherwise.
+ */
+export async function sendFeedbackRemote(payload) {
+    const result = await deliverFeedbackRemote(payload);
+    return result.ok;
 }
 //# sourceMappingURL=feedback-remote.js.map

package/dist/storage/feedback-store.d.ts

@@ -1,4 +1,4 @@
-import type { FeedbackEntry, FeedbackFilter, FeedbackSummary } from '../types/index.js';
+import type { FeedbackEntry, FeedbackFilter, FeedbackSummary, FeedbackRemoteHealth, SyncFeedbackInput, SyncFeedbackSummary } from '../types/index.js';
 /**
  * Submit a new feedback entry. Auto-generates ID, timestamp, and version.
  */
@@ -19,6 +19,8 @@ export declare function resolveFeedback(dataDir: string, id: string, specId?: st
  * Compute summary statistics across all feedback.
  */
 export declare function getSummary(dataDir: string): FeedbackSummary;
+export declare function getFeedbackRemoteHealth(dataDir: string): FeedbackRemoteHealth;
+export declare function syncFeedbackRemote(dataDir: string, input?: SyncFeedbackInput): Promise<SyncFeedbackSummary>;
 /**
  * Find feedback entries with title similar to the given string.
  * Uses Jaccard word overlap. Threshold defaults to 0.3.

package/dist/storage/feedback-store.js

@@ -2,7 +2,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { withFileLock } from './file-mutex.js';
-import { sendFeedbackRemote } from './feedback-remote.js';
+import { deliverFeedbackRemote } from './feedback-remote.js';
 // ---------------------------------------------------------------------------
 // Path helpers
 // ---------------------------------------------------------------------------
@@ -37,6 +37,54 @@ function writeLedger(filePath, entries) {
     ensureDir(dirname(filePath));
     writeFileSync(filePath, JSON.stringify(entries, null, 2), 'utf-8');
 }
+function getRemoteStatus(entry) {
+    return entry.remoteDelivery?.status ?? 'pending';
+}
+function toRemotePayload(entry) {
+    return {
+        id: entry.id,
+        type: entry.type,
+        title: entry.title,
+        description: entry.description,
+        planuVersion: entry.planuVersion,
+        stack: entry.context?.stack,
+        tags: entry.tags,
+    };
+}
+function toRemoteDelivery(entry, result) {
+    const now = new Date().toISOString();
+    const previousAttempts = entry.remoteDelivery?.attemptCount ?? 0;
+    return {
+        status: result.status,
+        attemptCount: previousAttempts + 1,
+        lastAttemptAt: now,
+        ...(result.ok ? { lastSyncedAt: now } : {}),
+        ...(result.error !== undefined ? { lastError: result.error.slice(0, 300) } : {}),
+        ...(result.endpoint !== undefined ? { endpoint: result.endpoint } : {}),
+    };
+}
+async function updateRemoteDelivery(dataDir, id, result) {
+    const filePath = getFeedbackPath(dataDir);
+    return withFileLock(filePath, () => {
+        const entries = readLedger(filePath);
+        const idx = entries.findIndex((e) => e.id === id);
+        const existing = entries[idx];
+        if (idx === -1 || existing === undefined) {
+            return Promise.resolve(null);
+        }
+        const updated = {
+            ...existing,
+            remoteDelivery: toRemoteDelivery(existing, result),
+        };
+        entries[idx] = updated;
+        writeLedger(filePath, entries);
+        return Promise.resolve(updated);
+    });
+}
+async function deliverAndPersistRemote(dataDir, entry) {
+    const result = await deliverFeedbackRemote(toRemotePayload(entry));
+    return (await updateRemoteDelivery(dataDir, entry.id, result)) ?? entry;
+}
 // ---------------------------------------------------------------------------
 // ID generation
 // ---------------------------------------------------------------------------
@@ -144,18 +192,12 @@ export async function submitFeedback(dataDir, entry) {
             id,
             createdAt: new Date().toISOString(),
             planuVersion: version,
+            remoteDelivery: { status: 'pending', attemptCount: 0 },
         };
         entries.push(newEntry);
         writeLedger(filePath, entries);
-        void sendFeedbackRemote({
-            type: newEntry.type,
-            title: newEntry.title,
-            description: newEntry.description,
-            planuVersion: newEntry.planuVersion,
-            stack: newEntry.context?.stack,
-            tags: newEntry.tags,
-        }).catch((err) => {
-            console.error('[planu] sendFeedbackRemote failed:', err);
+        void deliverAndPersistRemote(dataDir, newEntry).catch((err) => {
+            console.error('[planu] feedback remote delivery failed:', err);
         });
         return Promise.resolve(newEntry);
     });
@@ -259,6 +301,61 @@ export function getSummary(dataDir) {
         topRequests,
     };
 }
+export function getFeedbackRemoteHealth(dataDir) {
+    const entries = readLedger(getFeedbackPath(dataDir));
+    const byRemoteStatus = {
+        pending: 0,
+        synced: 0,
+        failed: 0,
+        skipped: 0,
+    };
+    for (const entry of entries) {
+        byRemoteStatus[getRemoteStatus(entry)]++;
+    }
+    return {
+        byRemoteStatus,
+        retryable: byRemoteStatus.pending + byRemoteStatus.failed,
+    };
+}
+export async function syncFeedbackRemote(dataDir, input = {}) {
+    const limit = input.limit !== undefined && input.limit > 0 ? input.limit : Number.POSITIVE_INFINITY;
+    const entries = readLedger(getFeedbackPath(dataDir));
+    const summary = {
+        total: 0,
+        synced: 0,
+        failed: 0,
+        skipped: 0,
+        alreadySynced: 0,
+        processedIds: [],
+    };
+    for (const entry of entries) {
+        if (summary.total >= limit) {
+            break;
+        }
+        const status = getRemoteStatus(entry);
+        if (status === 'synced' && input.includeSynced !== true) {
+            summary.alreadySynced++;
+            continue;
+        }
+        if (!['pending', 'failed', 'skipped', 'synced'].includes(status)) {
+            continue;
+        }
+        summary.total++;
+        summary.processedIds.push(entry.id);
+        const updated = await deliverAndPersistRemote(dataDir, entry);
+        const updatedStatus = getRemoteStatus(updated);
+        if (updatedStatus === 'synced') {
+            summary.synced++;
+        }
+        else if (updatedStatus === 'skipped') {
+            summary.skipped++;
+        }
+        else {
+            summary.failed++;
+        }
+    }
+    return summary;
+}
 /**
  * Find feedback entries with title similar to the given string.
  * Uses Jaccard word overlap. Threshold defaults to 0.3.

package/dist/tools/feedback-handler.d.ts

@@ -1,5 +1,7 @@
-import type { ToolResult, SubmitFeedbackInput, TriageFeedbackInput, ResolveFeedbackInput } from '../types/index.js';
+import type { ToolResult, SubmitFeedbackInput, TriageFeedbackInput, ResolveFeedbackInput, SyncFeedbackInput, FeedbackStatusInput } from '../types/index.js';
 export declare function handleSubmitFeedback(input: SubmitFeedbackInput): Promise<ToolResult>;
 export declare function handleTriageFeedback(input: TriageFeedbackInput): ToolResult;
 export declare function handleResolveFeedback(input: ResolveFeedbackInput): Promise<ToolResult>;
+export declare function handleSyncFeedback(input: SyncFeedbackInput): Promise<ToolResult>;
+export declare function handleFeedbackStatus(input: FeedbackStatusInput): ToolResult;
 //# sourceMappingURL=feedback-handler.d.ts.map

package/dist/tools/feedback-handler.js

@@ -1,6 +1,6 @@
 // tools/feedback-handler.ts — Feedback Hub tool handlers (SPEC-188)
 import { join } from 'node:path';
-import { submitFeedback, getFeedback, resolveFeedback, findSimilar, } from '../storage/feedback-store.js';
+import { submitFeedback, getFeedback, resolveFeedback, findSimilar, getSummary, getFeedbackRemoteHealth, syncFeedbackRemote, } from '../storage/feedback-store.js';
 import { triageFeedback, formatTriageReport } from '../engine/feedback/triage.js';
 // ---------------------------------------------------------------------------
 // Default data directory
@@ -43,6 +43,7 @@ export async function handleSubmitFeedback(input) {
         `| Type | ${TYPE_EMOJI[feedbackType]} |`,
         `| Title | ${entry.title} |`,
         `| Status | Pending |`,
+        `| Remote Delivery | ${entry.remoteDelivery?.status ?? 'pending'} |`,
     ];
     if (topSimilar !== undefined) {
         lines.push('');
@@ -103,4 +104,49 @@ export async function handleResolveFeedback(input) {
     }
     return { content: [{ type: 'text', text: lines.join('\n') }] };
 }
+// ---------------------------------------------------------------------------
+// sync_feedback handler
+// ---------------------------------------------------------------------------
+export async function handleSyncFeedback(input) {
+    const dataDir = getDataDir(input.projectPath);
+    const summary = await syncFeedbackRemote(dataDir, input);
+    const lines = [
+        'Feedback remote sync complete.',
+        '',
+        '| Field | Value |',
+        '|-------|-------|',
+        `| Processed | ${summary.total} |`,
+        `| Synced | ${summary.synced} |`,
+        `| Failed | ${summary.failed} |`,
+        `| Skipped | ${summary.skipped} |`,
+        `| Already Synced | ${summary.alreadySynced} |`,
+    ];
+    if (summary.processedIds.length > 0) {
+        lines.push(`| Processed IDs | ${summary.processedIds.join(', ')} |`);
+    }
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
+// ---------------------------------------------------------------------------
+// feedback_status handler
+// ---------------------------------------------------------------------------
+export function handleFeedbackStatus(input) {
+    const dataDir = getDataDir(input.projectPath);
+    const summary = getSummary(dataDir);
+    const remote = getFeedbackRemoteHealth(dataDir);
+    const lines = [
+        'Feedback status',
+        '',
+        '| Field | Value |',
+        '|-------|-------|',
+        `| Total | ${summary.total} |`,
+        `| Pending Local | ${summary.pending} |`,
+        `| Resolved Local | ${summary.resolved} |`,
+        `| Remote Pending | ${remote.byRemoteStatus.pending} |`,
+        `| Remote Synced | ${remote.byRemoteStatus.synced} |`,
+        `| Remote Failed | ${remote.byRemoteStatus.failed} |`,
+        `| Remote Skipped | ${remote.byRemoteStatus.skipped} |`,
+        `| Retryable | ${remote.retryable} |`,
+    ];
+    return { content: [{ type: 'text', text: lines.join('\n') }] };
+}
 //# sourceMappingURL=feedback-handler.js.map

package/dist/tools/register-sdd-tools.d.ts

@@ -1,4 +1,4 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare const OFFICIAL_SDD_TOOL_NAMES: readonly ["planu_status", "facilitate", "init_project", "clarify_requirements", "create_spec", "challenge_spec", "check_readiness", "update_status", "update_status_batch", "package_handoff", "validate", "reconcile_spec", "create_rule", "create_skill", "skill_search", "configure_code_graph", "code_graph_status"];
+export declare const OFFICIAL_SDD_TOOL_NAMES: readonly ["planu_status", "facilitate", "init_project", "clarify_requirements", "create_spec", "challenge_spec", "check_readiness", "update_status", "update_status_batch", "package_handoff", "validate", "reconcile_spec", "create_rule", "create_skill", "skill_search", "configure_code_graph", "code_graph_status", "submit_feedback", "triage_feedback", "resolve_feedback", "sync_feedback", "feedback_status"];
 export declare function registerSddTools(server: McpServer): void;
 //# sourceMappingURL=register-sdd-tools.d.ts.map

package/dist/tools/register-sdd-tools.js

@@ -30,6 +30,11 @@ export const OFFICIAL_SDD_TOOL_NAMES = [
     'skill_search',
     'configure_code_graph',
     'code_graph_status',
+    'submit_feedback',
+    'triage_feedback',
+    'resolve_feedback',
+    'sync_feedback',
+    'feedback_status',
 ];
 const OFFICIAL_SDD_TOOL_SET = new Set(OFFICIAL_SDD_TOOL_NAMES);
 const noop = () => undefined;

package/dist/tools/status-handler.js

@@ -27,19 +27,13 @@ const execFile = promisify(execFileCb);
 // ---------------------------------------------------------------------------
 async function getGitState(projectPath) {
     try {
-        const [statusResult, branchResult] = await Promise.all([
-            execFile('git', ['status', '--short'], { cwd: projectPath }),
+        const [stagedResult, modifiedResult, branchResult] = await Promise.all([
+            execFile('git', ['diff', '--cached', '--name-only'], { cwd: projectPath }),
+            execFile('git', ['diff', '--name-only'], { cwd: projectPath }),
             execFile('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: projectPath }),
         ]);
-        const lines = statusResult.stdout.trim().split('\n').filter(Boolean);
-        const staged = lines.filter((l) => {
-            const ch = l[0];
-            return ch !== ' ' && ch !== '?';
-        }).length;
-        const modified = lines.filter((l) => {
-            const ch = l[1];
-            return ch !== ' ' && ch !== '?';
-        }).length;
+        const staged = countGitPathLines(stagedResult.stdout);
+        const modified = countGitPathLines(modifiedResult.stdout);
         const branch = branchResult.stdout.trim();
         return { staged, modified, branch };
     }
@@ -47,6 +41,12 @@ async function getGitState(projectPath) {
         return null;
     }
 }
+function countGitPathLines(stdout) {
+    return stdout
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean).length;
+}
 // ---------------------------------------------------------------------------
 // CI state helpers
 // ---------------------------------------------------------------------------