@lsctech/polaris 0.5.11 → 0.5.13

package/dist/finalize/run-report.js

@@ -1,12 +1,179 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateRunReport = generateRunReport;
+const score_js_1 = require("../autoresearch/score.js");
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((v) => typeof v === "string");
+}
+function inferCompatibilityMode(selectionReason) {
+    if (!selectionReason)
+        return null;
+    if (selectionReason === "policy-router" || selectionReason.startsWith("router-")) {
+        return "router";
+    }
+    return "compatibility";
+}
+function buildRoutingCell(childId, state, telemetryEvents) {
+    const meta = asRecord(state.open_children_meta?.[childId]);
+    const dispatchRecord = asRecord(meta?.["dispatch_record"]);
+    const result = asRecord(state.completed_children_results?.[childId]);
+    const completed = state.completed_children.includes(childId);
+    const status = completed ? "Done" : "Open";
+    const findEvent = (eventName) => {
+        const found = telemetryEvents.find((e) => {
+            const rec = asRecord(e);
+            return rec?.["event"] === eventName && rec?.["child_id"] === childId;
+        });
+        return asRecord(found);
+    };
+    const completeEvent = findEvent("child-complete");
+    const dispatchedEvent = findEvent("child-dispatched");
+    const selectedEvent = findEvent("provider-selected");
+    const selectedSlotClaim = asRecord(dispatchedEvent?.["selected_slot_claim"]);
+    const routingSummary = asRecord(completeEvent?.["routing_summary"] ??
+        selectedEvent?.["routing_summary"] ??
+        dispatchedEvent?.["routing_summary"] ??
+        dispatchRecord?.["routing_summary"]);
+    const provider = asString(completeEvent?.["provider"] ??
+        selectedEvent?.["selected_provider"] ??
+        dispatchedEvent?.["provider"] ??
+        dispatchRecord?.["provider"] ??
+        result?.["provider"]);
+    const selectionReason = asString(completeEvent?.["router_selection_reason"] ??
+        selectedEvent?.["selection_reason"] ??
+        routingSummary?.["selection_reason"] ??
+        dispatchRecord?.["provider_selection_reason"] ??
+        selectedSlotClaim?.["selection_reason"]) ?? "—";
+    const compatibilityMode = typeof routingSummary?.["compatibility_mode"] === "boolean"
+        ? routingSummary["compatibility_mode"]
+        : typeof selectedEvent?.["router_compatibility_mode"] === "boolean"
+            ? selectedEvent["router_compatibility_mode"]
+            : null;
+    const mode = compatibilityMode === true
+        ? "compatibility"
+        : compatibilityMode === false
+            ? "router"
+            : inferCompatibilityMode(selectionReason) ?? "—";
+    const policyOrder = asStringArray(routingSummary?.["effective_policy_order"] ??
+        selectedEvent?.["providers_tried"] ??
+        completeEvent?.["providers_tried"] ??
+        dispatchedEvent?.["providers_tried"] ??
+        dispatchRecord?.["providers_tried"]);
+    const candidatesRaw = selectedEvent?.["router_candidates"];
+    const candidateCount = Array.isArray(candidatesRaw) ? candidatesRaw.length : null;
+    const fallbackRaw = selectedEvent?.["fallback_attempts"];
+    const fallbackAttempts = Array.isArray(fallbackRaw) ? fallbackRaw : [];
+    const fallbackCount = fallbackAttempts.filter((a) => asRecord(a)?.["outcome"] === "rejected").length;
+    const title = asString(meta?.["title"]) ?? "—";
+    return {
+        childId,
+        title,
+        provider: provider ?? "delegated",
+        selectionReason,
+        mode,
+        policyOrder,
+        candidateCount,
+        fallbackCount,
+        status,
+    };
+}
+function renderRoutingSection(state, telemetryEvents) {
+    const allChildren = [...state.completed_children, ...state.open_children];
+    const cells = allChildren.map((id) => buildRoutingCell(id, state, telemetryEvents));
+    const rows = cells
+        .map((c) => `| ${c.childId} | ${c.title} | ${c.provider} | ${c.selectionReason} | ${c.mode} | ${c.policyOrder.join(", ") || "—"} | ${c.candidateCount === null ? "—" : c.candidateCount} | ${c.fallbackCount} | ${c.status} |`)
+        .join("\n");
+    const providerCounts = new Map();
+    for (const cell of cells) {
+        if (cell.provider === "delegated")
+            continue;
+        providerCounts.set(cell.provider, (providerCounts.get(cell.provider) ?? 0) + 1);
+    }
+    const distribution = Array.from(providerCounts.entries())
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .map(([provider, count]) => `${provider}: ${count}`)
+        .join(", ") || "—";
+    const artifacts = {
+        runId: state.run_id,
+        runDir: null,
+        clusterDir: null,
+        currentState: state,
+        ledgerEvents: [],
+        resultPackets: [],
+        workerResultContracts: [],
+        telemetryEvents,
+        qcResults: [],
+        clusterState: null,
+    };
+    const outcomes = (0, score_js_1.summarizeRouterOutcomes)(artifacts);
+    const anomalyLines = [];
+    anomalyLines.push(`- Total routing decisions: ${outcomes.total_decisions}`);
+    anomalyLines.push(`- Exhausted decisions: ${outcomes.exhausted_decisions}`);
+    anomalyLines.push(`- Fallback attempts: ${outcomes.fallback_attempts} (${outcomes.successful_fallbacks} successful)`);
+    const hasAnomaly = outcomes.exhausted_decisions > 0 ||
+        outcomes.fallback_attempts > 0 ||
+        outcomes.recurring_failures.length > 0 ||
+        outcomes.provider_monopoly_signals.length > 0 ||
+        outcomes.evidence_gap_signals.length > 0 ||
+        outcomes.state_repair_signals.length > 0;
+    if (outcomes.recurring_failures.length > 0) {
+        anomalyLines.push(`- Recurring router failures:`);
+        for (const failure of outcomes.recurring_failures) {
+            anomalyLines.push(`  - ${failure.reason}: ${failure.occurrences} occurrence(s) — children: ${failure.child_ids.join(", ") || "none"}`);
+        }
+    }
+    if (outcomes.provider_monopoly_signals.length > 0) {
+        anomalyLines.push(`- Provider monopoly (repeated same-provider selection):`);
+        for (const signal of outcomes.provider_monopoly_signals) {
+            anomalyLines.push(`  - ${signal.reason}: ${signal.occurrences} occurrence(s) — children: ${signal.child_ids.join(", ") || "none"}`);
+        }
+    }
+    if (outcomes.evidence_gap_signals.length > 0) {
+        anomalyLines.push(`- Evidence gaps:`);
+        for (const signal of outcomes.evidence_gap_signals) {
+            anomalyLines.push(`  - ${signal.reason}: ${signal.occurrences} occurrence(s) — children: ${signal.child_ids.join(", ") || "none"}`);
+        }
+    }
+    if (outcomes.state_repair_signals.length > 0) {
+        anomalyLines.push(`- State repair / runtime review signals:`);
+        for (const signal of outcomes.state_repair_signals) {
+            anomalyLines.push(`  - ${signal.signal} (${signal.reason}): ${signal.occurrences} occurrence(s) — children: ${signal.child_ids.join(", ") || "none"}`);
+        }
+    }
+    const anomaliesText = hasAnomaly
+        ? anomalyLines.join("\n")
+        : "No routing anomalies or evidence gaps detected.";
+    return `### Provider distribution
+
+| Child | Title | Provider | Selection reason | Mode | Policy order | Candidates | Fallbacks | Status |
+|---|---|---|---|---|---|---|---|---|
+${rows || "| _No children recorded_ | — | — | — | — | — | — | — | — |"}
+
+**Provider summary:** ${distribution}
+
+### Routing review
+
+${anomaliesText}`;
+}
 function renderQcSection(qcSummary) {
     if (!qcSummary)
         return "";
-    const { total_findings, blocking_findings, autofixed_findings, repaired_findings, waived_findings, unvalidated_findings, open_by_severity, blocks_delivery, qc_run_count, weighted_open_score, qc_penalty, provider_breakdown, routing_breakdown } = qcSummary;
-    const openTotal = open_by_severity.critical + open_by_severity.high +
-        open_by_severity.medium + open_by_severity.low + open_by_severity.info;
+    const { total_findings, blocking_findings, autofixed_findings, repaired_findings, waived_findings, unvalidated_findings, open_by_severity, blocks_delivery, qc_run_count, weighted_open_score, qc_penalty, provider_breakdown, routing_breakdown, } = qcSummary;
+    const openTotal = open_by_severity.critical +
+        open_by_severity.high +
+        open_by_severity.medium +
+        open_by_severity.low +
+        open_by_severity.info;
     const deliveryStatus = blocks_delivery
         ? "**BLOCKED** — unresolved critical/high findings must be addressed before delivery"
         : "Not blocking delivery";
@@ -51,11 +218,10 @@ ${providers || "| _none_ | — | — | — |"}
 
 | Decision | Count |
 |---|---|
-${routing}
-`;
+${routing}`;
 }
 function generateRunReport(data) {
-    const { state, branch, validationPassed, prUrl, artifacts, notes, qcSummary } = data;
+    const { state, branch, validationPassed, prUrl, artifacts, notes, qcSummary, telemetryEvents } = data;
     const total = state.completed_children.length + state.open_children.length;
     const completedCount = state.completed_children.length;
     const childRows = state.completed_children
@@ -72,21 +238,25 @@ function generateRunReport(data) {
         ? `\n**Blocker:** ${state.blocker.reason} (child: ${state.blocker.child_id})\n`
         : "";
     const qcSection = renderQcSection(qcSummary);
+    const routingSection = renderRoutingSection(state, telemetryEvents ?? []);
     return `# Run Report: ${state.run_id}
 
-  | Field | Value |
-  |---|---|
-  | **Status** | ${state.status} |
-  | **Branch** | ${branch} |
-  | **PR** | ${prUrl ?? "TBD — set at delivery step 9"} |
-  | **Children completed** | ${completedCount} of ${total} |
-  | **Validation** | ${validationPassed ? "passed" : "failed"} |
-  ${blockerNote}
-  ## Children
-
-  | ID | Title | Commit | Status |
-  |---|---|---|---|
-  ${childRows || "_No children recorded_"}
+| Field | Value |
+|---|---|
+| **Status** | ${state.status} |
+| **Branch** | ${branch} |
+| **PR** | ${prUrl ?? "TBD — set at delivery step 9"} |
+| **Children completed** | ${completedCount} of ${total} |
+| **Validation** | ${validationPassed ? "passed" : "failed"} |
+${blockerNote}## Children
+
+| ID | Title | Commit | Status |
+|---|---|---|---|
+${childRows || "_No children recorded_"}
+
+## Provider routing
+
+${routingSection}
 
 ## Artifacts produced
 

package/dist/finalize/steps/05-generate-report.js

@@ -3,11 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.stepGenerateReport = stepGenerateReport;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const continue_js_1 = require("../../loop/continue.js");
+const gates_js_1 = require("../../autoresearch/gates.js");
 const run_report_js_1 = require("../run-report.js");
 function stepGenerateReport(repoRoot, state, branch, validationPassed) {
     const reportPath = (0, node_path_1.resolve)(repoRoot, ".polaris", "runs", "run-report.md");
     (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(reportPath), { recursive: true });
-    const content = (0, run_report_js_1.generateRunReport)({ state, branch, validationPassed });
+    const telemetryFile = (0, continue_js_1.resolveTelemetryFilePath)(state, repoRoot);
+    const telemetryEvents = (0, gates_js_1.readJsonLines)(telemetryFile);
+    const content = (0, run_report_js_1.generateRunReport)({ state, branch, validationPassed, telemetryEvents });
     (0, node_fs_1.writeFileSync)(reportPath, content, "utf-8");
     console.log(`Run report written: ${reportPath}`);
     return reportPath;

package/dist/finalize/steps/12-archive.js

@@ -17,5 +17,11 @@ function stepArchive(repoRoot, state, stateFile, reportPath) {
             (0, node_fs_1.copyFileSync)(src, (0, node_path_1.join)(archiveDir, file));
         }
     }
+    const artifactDir = state.artifact_dir
+        ?? (0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-run");
+    const telemetryFile = (0, node_path_1.resolve)(repoRoot, artifactDir, "runs", state.run_id, "telemetry.jsonl");
+    if ((0, node_fs_1.existsSync)(telemetryFile)) {
+        (0, node_fs_1.copyFileSync)(telemetryFile, (0, node_path_1.join)(archiveDir, "telemetry.jsonl"));
+    }
     console.log(`Run archived to .polaris/runs/${state.run_id}/`);
 }

package/dist/loop/adapters/terminal-cli.js

@@ -494,31 +494,81 @@ class TerminalCliAdapter {
             // Normalize legacy CompactReturn shapes before validation so that
             // workers using pre-spec formats (status:"success", validation:{passed:[...]})
             // are accepted rather than silently marked as failures.
-            const normalized = normalizeLegacyCompactReturn(parsed);
-            const compactReturnErrors = (0, compact_return_js_1.validateCompactReturn)(normalized);
+            const normalized = normalizeLegacyCompactReturn(parsed, packet.active_child);
+            const compact = buildCompactReturnForSealedResult(normalized, exitCode);
+            const compactReturnErrors = (0, compact_return_js_1.validateCompactReturn)(compact);
             const isValidCompactReturn = compactReturnErrors.length === 0;
-            // If the parsed result isn't a valid CompactReturn, treat it as a failure
-            // regardless of exit code — this prevents phantom successes from workers
-            // that return minimal status objects instead of proper CompactReturn structs.
-            const effectiveStatus = (exitCode === 0 && isValidCompactReturn) ? "success" : "failure";
+            let finalStatus = isValidCompactReturn
+                ? compact["status"]
+                : "failed";
+            let finalValidation = isValidCompactReturn
+                ? compact["validation"]
+                : "failed";
+            let finalNext = isValidCompactReturn
+                ? compact["next_recommended_action"]
+                : "stop";
+            // Reconcile validation/next_recommended_action with run-health symptoms.
+            // A validation-failed symptom overrides a passing validation string and
+            // prevents a continue recommendation when the build/tests did not pass.
+            const rawSymptoms = compact["run_health_symptoms"];
+            const hasValidationFailedSymptom = Array.isArray(rawSymptoms) &&
+                rawSymptoms.some((s) => typeof s === "object" &&
+                    s !== null &&
+                    s["category"] === "validation-failed");
+            if (hasValidationFailedSymptom) {
+                finalValidation = "failed";
+                finalNext = "stop";
+            }
+            // "continue" requires a passing validation result. If validation failed,
+            // the recommendation must be a terminal stop. If validation was skipped,
+            // treat the successful exit as a pass for the completion contract.
+            if (finalStatus === "done" && finalNext === "continue") {
+                if (finalValidation === "failed") {
+                    finalNext = "stop";
+                }
+                else if (finalValidation === "skipped") {
+                    finalValidation = "passed";
+                }
+            }
+            // A failed status should never recommend continuation.
+            if ((finalStatus === "failed" || finalStatus === "blocked") && finalNext === "continue") {
+                finalNext = "stop";
+            }
+            const errorMessage = finalStatus === "failed" || finalStatus === "blocked"
+                ? isValidCompactReturn
+                    ? typeof compact["error_message"] === "string"
+                        ? compact["error_message"]
+                        : typeof compact["blocker"] === "string"
+                            ? compact["blocker"]
+                            : stdout || summary
+                    : `CompactReturn validation failed: ${compactReturnErrors.join("; ")}`
+                : undefined;
             const sealedResult = {
                 run_id: packet.run_id,
-                child_id: String(normalized["child_id"] ?? packet.active_child),
-                status: effectiveStatus,
-                commit: typeof normalized["commit"] === "string"
-                    ? normalized["commit"]
-                    : typeof normalized["commit_hash"] === "string"
-                        ? normalized["commit_hash"]
-                        : undefined,
-                validation: normalized["validation"] ?? normalized["validation_summary"],
-                error_message: effectiveStatus === "failure"
-                    ? (!isValidCompactReturn
-                        ? `CompactReturn validation failed: ${compactReturnErrors.join("; ")}`
-                        : typeof normalized["error_message"] === "string"
-                            ? normalized["error_message"]
-                            : stdout || summary)
-                    : undefined,
+                cluster_id: packet.cluster_id,
+                child_id: compact["child_id"],
+                status: finalStatus,
+                commit: compact["commit"],
+                validation: finalValidation,
+                next_recommended_action: finalNext,
             };
+            if (isValidCompactReturn) {
+                if (compact["result_data"] !== undefined) {
+                    sealedResult["result_data"] = compact["result_data"];
+                }
+                if (compact["work_note_paths"] !== undefined) {
+                    sealedResult["work_note_paths"] = compact["work_note_paths"];
+                }
+            }
+            if (Array.isArray(compact["run_health_symptoms"])) {
+                sealedResult["run_health_symptoms"] = compact["run_health_symptoms"];
+            }
+            if (finalStatus === "blocked" && typeof compact["blocker"] === "string") {
+                sealedResult["blocker"] = compact["blocker"];
+            }
+            if (errorMessage !== undefined) {
+                sealedResult["error_message"] = errorMessage;
+            }
             node_fs_1.default.mkdirSync(node_path_1.default.dirname(resultFile), { recursive: true });
             node_fs_1.default.writeFileSync(resultFile, JSON.stringify(sealedResult, null, 2), "utf-8");
         }
@@ -533,14 +583,26 @@ exports.TerminalCliAdapter = TerminalCliAdapter;
  * Normalize a legacy CompactReturn shape to the current spec before validation.
  * Handles pre-spec formats produced by older workers:
  *   - status:"success"|"completed" → status:"done"
+ *   - status:"failure"|"error"|"in-progress" → status:"failed"
  *   - validation:{passed:[...],failed:[...]} → validation:"passed"|"failed"|"skipped"
+ *   - next_action:"continue"|"stop"|"escalate" → next_recommended_action
  *   - missing boolean flags → false
+ *   - missing or empty child_id → active_child from the bootstrap packet
  */
-function normalizeLegacyCompactReturn(raw) {
+function normalizeLegacyCompactReturn(raw, activeChild) {
     const result = { ...raw };
+    if (typeof result['child_id'] !== 'string' || !result['child_id']) {
+        result['child_id'] = activeChild;
+    }
     if (result['status'] === 'success' || result['status'] === 'completed') {
         result['status'] = 'done';
     }
+    else if (result['status'] === 'failure' || result['status'] === 'error' || result['status'] === 'in-progress') {
+        result['status'] = 'failed';
+    }
+    else if (result['status'] !== 'done' && result['status'] !== 'failed' && result['status'] !== 'blocked') {
+        result['status'] = 'failed';
+    }
     if (typeof result['validation'] === 'object' && result['validation'] !== null) {
         const v = result['validation'];
         if (Array.isArray(v['failed']) && v['failed'].length > 0) {
@@ -553,6 +615,19 @@ function normalizeLegacyCompactReturn(raw) {
             result['validation'] = 'skipped';
         }
     }
+    if (typeof result['next_action'] === 'string' && !result['next_recommended_action']) {
+        const action = result['next_action'];
+        if (action === 'continue') {
+            result['next_recommended_action'] = 'continue';
+        }
+        else if (action === 'stop') {
+            result['next_recommended_action'] = 'stop';
+        }
+        else if (action === 'escalate') {
+            result['next_recommended_action'] = 'investigate';
+        }
+        delete result['next_action'];
+    }
     for (const flag of ['tracker_updated', 'state_updated', 'telemetry_updated']) {
         if (typeof result[flag] !== 'boolean') {
             result[flag] = false;
@@ -560,9 +635,63 @@ function normalizeLegacyCompactReturn(raw) {
     }
     return result;
 }
+function compactReturnDefaults(status) {
+    return {
+        validation: status === 'done' ? 'passed' : status === 'failed' ? 'failed' : 'skipped',
+        next_recommended_action: status === 'done' ? 'continue' : 'stop',
+    };
+}
+function resolveCommit(raw) {
+    if (typeof raw['commit'] === 'string') {
+        return raw['commit'];
+    }
+    if (typeof raw['commit_hash'] === 'string') {
+        return raw['commit_hash'];
+    }
+    if (typeof raw['commit_sha'] === 'string') {
+        return raw['commit_sha'];
+    }
+    return null;
+}
+function isValidValidation(value) {
+    return value === 'passed' || value === 'failed' || value === 'skipped';
+}
+function isValidNextAction(value) {
+    return value === 'continue' || value === 'stop' || value === 'investigate';
+}
+function buildCompactReturnForSealedResult(normalized, exitCode) {
+    const rawStatus = normalized['status'];
+    let baseStatus;
+    if (rawStatus === 'done' || rawStatus === 'failed' || rawStatus === 'blocked') {
+        baseStatus = rawStatus;
+    }
+    else {
+        baseStatus = 'failed';
+    }
+    const effectiveStatus = exitCode === 0
+        ? baseStatus
+        : baseStatus === 'failed' || baseStatus === 'blocked'
+            ? baseStatus
+            : 'failed';
+    const defaults = compactReturnDefaults(effectiveStatus);
+    const compact = {
+        ...normalized,
+        child_id: String(normalized['child_id'] || ''),
+        status: effectiveStatus,
+        commit: resolveCommit(normalized),
+        validation: isValidValidation(normalized['validation']) ? normalized['validation'] : defaults.validation,
+        next_recommended_action: isValidNextAction(normalized['next_recommended_action'])
+            ? normalized['next_recommended_action']
+            : defaults.next_recommended_action,
+        tracker_updated: typeof normalized['tracker_updated'] === 'boolean' ? normalized['tracker_updated'] : false,
+        state_updated: typeof normalized['state_updated'] === 'boolean' ? normalized['state_updated'] : false,
+        telemetry_updated: typeof normalized['telemetry_updated'] === 'boolean' ? normalized['telemetry_updated'] : false,
+    };
+    return compact;
+}
 /**
  * Extract a worker summary from stdout.
- * Looks for the last line that is valid JSON; falls back to the last 500 chars.
+ * Looks for the last line that is a valid JSON *object*; falls back to the last 500 chars.
  */
 function extractSummary(stdout) {
     if (!stdout)
@@ -573,8 +702,13 @@ function extractSummary(stdout) {
         if (!trimmed)
             continue;
         try {
-            JSON.parse(trimmed);
-            return trimmed;
+            const parsed = JSON.parse(trimmed);
+            if (typeof parsed === 'object' &&
+                parsed !== null &&
+                !Array.isArray(parsed)) {
+                return trimmed;
+            }
+            // not an object-shaped JSON value, keep looking
         }
         catch {
             // not JSON, keep looking

package/dist/loop/body-parser.js

@@ -150,6 +150,71 @@ function parseListItems(text) {
 function stripTrailingParenthetical(s) {
     return s.replace(/\s*\([^)]*\)\s*$/, '').trim();
 }
+/** Returns true for tokens that look like a file path or glob pattern. */
+function isPathLikeToken(token) {
+    return (token.includes('/') ||
+        token.includes('*') ||
+        token.includes('.') ||
+        token.includes('?'));
+}
+/**
+ * Normalizes a bare directory path into a glob pattern so that
+ * matchesAllowedScope() treats it as the directory and its contents.
+ */
+function normalizeDirectoryPattern(pattern) {
+    if (pattern.endsWith('/') && !pattern.endsWith('/**')) {
+        return pattern + '**';
+    }
+    // Extract the final path segment to check for extensions
+    const lastSlashIndex = pattern.lastIndexOf('/');
+    const finalSegment = lastSlashIndex >= 0 ? pattern.slice(lastSlashIndex + 1) : pattern;
+    // Dot-files that are files, not directories, must not get a trailing `/**`.
+    if (finalSegment === '.gitignore' || finalSegment === '.gitattributes') {
+        return pattern;
+    }
+    // Check if final segment has a file extension (not counting leading dot in dot-directories)
+    const hasExtension = finalSegment.startsWith('.')
+        ? finalSegment.slice(1).includes('.') // For .github, .vscode: no extension. For .env.local: has extension
+        : finalSegment.includes('.');
+    if (!hasExtension &&
+        !pattern.endsWith('*') &&
+        !pattern.endsWith('?')) {
+        return pattern + '/**';
+    }
+    return pattern;
+}
+/**
+ * Extracts bare file/glob patterns from a raw scope bullet line.
+ *
+ * Strips backticks and trailing prose (e.g. `src/foo.ts some comment`), splits
+ * comma/semicolon separated entries, and returns only path-like leading tokens.
+ */
+function parseScopeItem(raw) {
+    const cleaned = raw.replace(/`/g, '').trim();
+    if (cleaned.length === 0)
+        return [];
+    const parts = cleaned
+        .split(/[,;]+/)
+        .map((s) => stripTrailingParenthetical(s.trim()))
+        .filter((s) => s.length > 0);
+    const results = [];
+    for (const part of parts) {
+        const tokens = part.split(/\s+/);
+        const pathTokens = [];
+        for (const token of tokens) {
+            if (isPathLikeToken(token)) {
+                pathTokens.push(token);
+            }
+            else {
+                break;
+            }
+        }
+        for (const pathToken of pathTokens) {
+            results.push(normalizeDirectoryPattern(pathToken));
+        }
+    }
+    return results;
+}
 /**
  * Extracts list items from the first section whose header matches a provided set.
  *
@@ -169,15 +234,15 @@ function findSection(sections, headers) {
     return [];
 }
 /**
- * Extracts list items from the Scope section, stripping trailing parenthetical annotations.
+ * Extracts raw list items from the Scope section, stripping trailing parenthetical annotations.
  *
  * Scope section items often include human-readable annotations like "(new)" or
- * "(thread flag through...)". These are stripped so that allowed_scope entries in
- * worker packets contain only bare file paths or valid glob patterns.
+ * "(thread flag through...)". These are stripped so that callers can then parse
+ * bare paths/globs with parseScopeItem.
  *
  * @param sections - Map of normalized header names to their section content
  * @param headers - Set of normalized Scope header variants (e.g., SCOPE_HEADERS)
- * @returns An array of scope paths with parentheticals removed, or an empty array if no Scope section is found
+ * @returns An array of raw scope strings with parentheticals removed, or an empty array if no Scope section is found
  */
 function findScopeSection(sections, headers) {
     for (const [header, content] of sections) {
@@ -230,9 +295,11 @@ function parseIssueBody(body) {
     const sections = parseSections(body);
     const rawScope = findScopeSection(sections, SCOPE_HEADERS);
     const scopeBlocked = rawScope.length > 0 && rawScope.every((item) => TBD_BLOCKED_RE.test(item));
-    const filteredScope = rawScope.filter((item) => !TBD_BLOCKED_RE.test(item));
+    const filteredScope = scopeBlocked
+        ? []
+        : rawScope.filter((item) => !TBD_BLOCKED_RE.test(item)).flatMap(parseScopeItem);
     return {
-        scope: scopeBlocked ? [] : filteredScope,
+        scope: filteredScope,
         scopeBlocked,
         validationCommands: findSection(sections, VALIDATION_HEADERS),
         requirements: findSection(sections, REQUIREMENTS_HEADERS),