agentic-devtools 0.2.87__tar.gz → 0.2.88__tar.gz

{agentic_devtools-0.2.87 → agentic_devtools-0.2.88}/.github/workflows/ai-pr-loop.yml

@@ -16,7 +16,6 @@ permissions:
 
 env:
   AGDT_USE_PYTHON_ORCHESTRATOR: "1"
-  AGDT_VERSION: '0.42.0'
 
 concurrency:
   group: ai-pr-loop-${{ github.event.pull_request.number || github.event.workflow_run.pull_requests[0].number || github.event.workflow_run.head_branch }}
@@ -48,7 +47,7 @@ jobs:
           python-version: '3.12'
 
       - name: Install agentic-devtools
-        run: pip install "agentic-devtools==${{ env.AGDT_VERSION }}"
+        run: pip install agentic-devtools
 
       - name: Run AI PR loop orchestrator
         env:

{agentic_devtools-0.2.87 → agentic_devtools-0.2.88}/.gitignore

@@ -68,6 +68,7 @@ poll*.json
 poll*.out
 poll*.err
 _poll*.txt
+_poll*.json
 
 # Workflow artifacts (ad-hoc, not source files)
 replies.json

{agentic_devtools-0.2.87 → agentic_devtools-0.2.88}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-devtools
-Version: 0.2.87
+Version: 0.2.88
 Summary: Agentic devtools integrate Jira, DevOps & more
 Author: ayaiayorg
 License-Expression: MIT

{agentic_devtools-0.2.87 → agentic_devtools-0.2.88}/agentic_devtools/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.87'
-__version_tuple__ = version_tuple = (0, 2, 87)
+__version__ = version = '0.2.88'
+__version_tuple__ = version_tuple = (0, 2, 88)
 
 __commit_id__ = commit_id = None

{agentic_devtools-0.2.87 → agentic_devtools-0.2.88}/agentic_devtools/cli/ci/commands.py

@@ -11,10 +11,14 @@ import json
 import os
 import shutil
 import sys
+import tempfile
 
 from agentic_devtools.cli.ci.exceptions import MalformedEventError
 from agentic_devtools.cli.ci.github_provider import GitHubActionsProvider
+from agentic_devtools.cli.ci.models import EventPayload
 from agentic_devtools.cli.ci.orchestrator import run_ai_pr_loop
+from agentic_devtools.cli.ci.speckit_trigger import process_speckit_label_event
+from agentic_devtools.cli.subprocess_utils import run_safe
 
 
 def _python_orchestrator_enabled() -> bool:
@@ -92,9 +96,9 @@ def speckit_trigger_command() -> None:
 
     Exit codes:
         0: Success
+        1: Processing failed (script error or missing outputs)
         2: Malformed event
         10: Missing dependency or configuration
-        11: Stub implementation — full logic not yet available
     """
     # Feature flag check
     if not _python_orchestrator_enabled():
@@ -123,21 +127,71 @@ def speckit_trigger_command() -> None:
     repo = os.environ.get("GITHUB_REPOSITORY", "")
     provider = GitHubActionsProvider(repo=repo)
 
+    synthetic_event_path: str | None = None
+    if event_name == "workflow_dispatch":
+        event_payload = _synthesize_workflow_dispatch_event(raw_payload, repo)
+        synthetic_event_path = os.environ.get("GITHUB_EVENT_PATH")
+    else:
+        try:
+            event_payload = provider.parse_event(raw_payload, event_name)
+        except MalformedEventError as exc:
+            json.dump({"error": "malformed_event", "event_name": exc.event_name, "reason": exc.reason}, sys.stderr)
+            sys.stderr.write("\n")
+            sys.exit(2)
+
     try:
-        event_payload = provider.parse_event(raw_payload, event_name)
-    except MalformedEventError as exc:
-        json.dump({"error": "malformed_event", "event_name": exc.event_name, "reason": exc.reason}, sys.stderr)
-        sys.stderr.write("\n")
+        exit_code = process_speckit_label_event(provider, event_payload)
+    finally:
+        if synthetic_event_path:
+            try:
+                os.unlink(synthetic_event_path)
+            except OSError:
+                pass
+    sys.exit(exit_code)
+
+
+def _synthesize_workflow_dispatch_event(raw_payload: dict, repo: str) -> EventPayload:
+    """Synthesize an issues-labeled EventPayload from a workflow_dispatch event.
+
+    Fetches issue data via ``gh api`` and writes a synthetic event file to
+    ``GITHUB_EVENT_PATH`` so that ``_load_issue_context_from_event()`` can
+    read the issue context as if it were a normal issues/labeled event.
+    """
+    inputs = raw_payload.get("inputs") or {}
+    issue_number_str = str(inputs.get("issue_number", "")).strip()
+    if not issue_number_str:
+        print("Error: workflow_dispatch requires 'issue_number' input.", file=sys.stderr)
         sys.exit(2)
 
-    # For now, just validate the event was parseable
-    # Full speckit trigger logic will be added in Phase 6
-    if event_payload.trigger_label:
-        print(f"SpecKit trigger: label='{event_payload.trigger_label}'")
+    if not issue_number_str.isdigit() or int(issue_number_str) <= 0:
+        print(f"Error: 'issue_number' must be a positive integer, got: {issue_number_str!r}", file=sys.stderr)
+        sys.exit(2)
+
+    if not repo or "/" not in repo:
+        print(f"Error: GITHUB_REPOSITORY must be in 'owner/repo' format, got: {repo!r}", file=sys.stderr)
+        sys.exit(10)
 
-    print(
-        "Error: agdt-speckit-trigger is using a stub implementation. "
-        "Full SpecKit trigger logic will be added in Phase 6.",
-        file=sys.stderr,
+    result = run_safe(
+        ["gh", "api", f"repos/{repo}/issues/{issue_number_str}"],
+        capture_output=True,
+        text=True,
+        shell=False,
     )
-    sys.exit(11)
+    if result.returncode != 0:
+        print(f"Error: Failed to fetch issue #{issue_number_str}: {result.stderr.strip()}", file=sys.stderr)
+        sys.exit(10)
+
+    try:
+        issue_data = json.loads(result.stdout)
+    except json.JSONDecodeError as exc:
+        print(f"Error: Failed to parse issue data: {exc}", file=sys.stderr)
+        sys.exit(10)
+
+    trigger_label = os.environ.get("SPECKIT_TRIGGER_LABEL", "speckit")
+    synthetic_event = {"issue": issue_data, "action": "labeled", "label": {"name": trigger_label}}
+
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False, encoding="utf-8") as f:
+        json.dump(synthetic_event, f)
+        os.environ["GITHUB_EVENT_PATH"] = f.name
+
+    return EventPayload(action="labeled", trigger_label=trigger_label)

agentic_devtools-0.2.88/agentic_devtools/cli/ci/speckit_trigger.py

@@ -0,0 +1,301 @@
+"""SpecKit trigger orchestration for issues label events."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+from agentic_devtools.cli.ci.models import EventPayload
+from agentic_devtools.cli.ci.provider import CIPlatformProvider
+from agentic_devtools.cli.subprocess_utils import run_safe
+
+logger = logging.getLogger(__name__)
+
+EXIT_SUCCESS = 0
+EXIT_FAILED = 1
+EXIT_MALFORMED_EVENT = 2
+EXIT_MISSING_CONFIG = 10
+
+_SPECKIT_PHASE_LABEL = "speckit:phase-1"
+_SPECKIT_PHASE_COMPLETE_LABEL = "speckit:phase-1-complete"
+_SPECKIT_PROCESSING_LABEL = "speckit:processing"
+_SPECKIT_FAILED_LABEL = "speckit:failed"
+
+
+@dataclass(frozen=True)
+class _IssueContext:
+    issue_number: int
+    issue_title: str
+    issue_body: str
+    issue_url: str
+    labels: list[str]
+
+
+def process_speckit_label_event(provider: CIPlatformProvider, event_payload: EventPayload) -> int:
+    """Process a SpecKit issues/labeled trigger event.
+
+    The ``provider`` argument is currently reserved for future provider-backed
+    API calls as this path still relies on existing shell scripts and ``gh`` CLI
+    commands for parity with the workflow implementation.
+    """
+    del provider  # reserved for future provider-backed execution
+
+    if event_payload.action != "labeled":
+        logger.info(
+            "Skipping SpecKit trigger: action %r is not 'labeled'",
+            event_payload.action,
+        )
+        return EXIT_SUCCESS
+
+    expected_trigger_label = os.environ.get("SPECKIT_TRIGGER_LABEL", "speckit")
+    if event_payload.trigger_label != expected_trigger_label:
+        logger.info(
+            "Skipping SpecKit trigger: label %r does not match configured trigger %r",
+            event_payload.trigger_label,
+            expected_trigger_label,
+        )
+        return EXIT_SUCCESS
+
+    if not os.environ.get("GITHUB_REPOSITORY", "").strip():
+        logger.error("GITHUB_REPOSITORY is required for SpecKit trigger processing")
+        return EXIT_MISSING_CONFIG
+
+    try:
+        issue = _load_issue_context_from_event()
+    except RuntimeError as exc:
+        logger.error("Failed to read issue context from event payload: %s", exc)
+        return EXIT_MALFORMED_EVENT
+
+    # Dedup guard for repeated trigger runs.
+    if (
+        _SPECKIT_PROCESSING_LABEL in issue.labels
+        or _SPECKIT_PHASE_LABEL in issue.labels
+        or _SPECKIT_PHASE_COMPLETE_LABEL in issue.labels
+    ):
+        logger.info(
+            "Skipping duplicate SpecKit trigger for issue #%d: phase already in progress/present",
+            issue.issue_number,
+        )
+        return EXIT_SUCCESS
+
+    try:
+        _set_issue_labels(
+            issue.issue_number,
+            add=[_SPECKIT_PROCESSING_LABEL],
+            remove=[expected_trigger_label, _SPECKIT_FAILED_LABEL],
+        )
+
+        idempotency = _run_script_with_outputs(
+            ".github/scripts/speckit-trigger/check-idempotency.sh",
+            [str(issue.issue_number), "--phase", "1"],
+        )
+        if idempotency.get("skipped") == "true":
+            _set_issue_labels(
+                issue.issue_number,
+                add=[_SPECKIT_PHASE_COMPLETE_LABEL],
+                remove=[_SPECKIT_PROCESSING_LABEL],
+            )
+            logger.info("Skipping issue #%d: phase 1 artifacts already exist", issue.issue_number)
+            return EXIT_SUCCESS
+
+        short_name_result = _run_script_with_outputs(
+            ".github/scripts/speckit-trigger/sanitize-branch-name.sh",
+            [issue.issue_title],
+        )
+        short_name = short_name_result.get("short_name", "").strip()
+        if not short_name:
+            raise RuntimeError("sanitize-branch-name.sh did not provide short_name")
+
+        generate_outputs = _run_script_with_outputs(
+            ".github/scripts/speckit-trigger/generate-spec-from-issue.sh",
+            ["--phase", "1"],
+            extra_env={
+                "ISSUE_NUMBER": str(issue.issue_number),
+                "ISSUE_TITLE": issue.issue_title,
+                "ISSUE_BODY": issue.issue_body,
+                "ISSUE_URL": issue.issue_url,
+                "SHORT_NAME": short_name,
+            },
+        )
+        spec_dir = generate_outputs.get("spec_dir", "").strip()
+        if not spec_dir:
+            raise RuntimeError("generate-spec-from-issue.sh did not provide spec_dir")
+
+        _commit_and_push_phase_branch(issue.issue_number, spec_dir)
+        _create_phase_pull_request(issue, spec_dir)
+    except RuntimeError as exc:
+        logger.error("SpecKit trigger failed: %s", exc)
+        try:
+            _set_issue_labels(
+                issue.issue_number,
+                add=[_SPECKIT_FAILED_LABEL],
+                remove=[_SPECKIT_PROCESSING_LABEL],
+            )
+        except RuntimeError as label_exc:
+            logger.warning("Failed to update failure labels: %s", label_exc)
+        return EXIT_FAILED
+
+    try:
+        _set_issue_labels(
+            issue.issue_number,
+            add=[_SPECKIT_PHASE_LABEL],
+            remove=[_SPECKIT_PROCESSING_LABEL],
+        )
+    except RuntimeError as exc:
+        logger.error("Failed to update labels after successful processing: %s", exc)
+        return EXIT_FAILED
+    return EXIT_SUCCESS
+
+
+def _load_issue_context_from_event() -> _IssueContext:
+    event_path = os.environ.get("GITHUB_EVENT_PATH", "")
+    if not event_path:
+        raise RuntimeError("GITHUB_EVENT_PATH is not set")
+
+    try:
+        with open(event_path, encoding="utf-8") as f:
+            raw_payload = json.load(f)
+    except (OSError, json.JSONDecodeError) as exc:
+        raise RuntimeError(f"failed to read event payload: {exc}") from exc
+
+    issue = raw_payload.get("issue", {})
+    if not isinstance(issue, dict):
+        raise RuntimeError("event payload 'issue' field is not a mapping")
+    issue_number = issue.get("number")
+    if not isinstance(issue_number, int) or issue_number <= 0:
+        raise RuntimeError("missing issue.number in event payload")
+
+    raw_labels = issue.get("labels", [])
+    if not isinstance(raw_labels, list):
+        raise RuntimeError("event payload 'issue.labels' field is not a list")
+    labels = [lbl.get("name", "") for lbl in raw_labels if isinstance(lbl, dict)]
+    return _IssueContext(
+        issue_number=issue_number,
+        issue_title=issue.get("title", ""),
+        issue_body=issue.get("body") or "",
+        issue_url=issue.get("html_url", "") or "",
+        labels=[name for name in labels if name],
+    )
+
+
+def _set_issue_labels(issue_number: int, *, add: list[str] | None = None, remove: list[str] | None = None) -> None:
+    add = [label for label in (add or []) if label]
+    remove = [label for label in (remove or []) if label]
+
+    base_cmd = ["gh", "issue", "edit", str(issue_number), "--repo", _require_repository()]
+    for label in add:
+        _run_checked(base_cmd + ["--add-label", label])
+    for label in remove:
+        _run_checked(base_cmd + ["--remove-label", label])
+
+
+def _run_script_with_outputs(
+    relative_script_path: str,
+    args: list[str],
+    *,
+    extra_env: dict[str, str] | None = None,
+) -> dict[str, str]:
+    script_path = Path(relative_script_path)
+    if not script_path.exists():
+        raise RuntimeError(f"script not found: {relative_script_path}")
+
+    env = dict(os.environ)
+    if extra_env:
+        env.update(extra_env)
+
+    with tempfile.NamedTemporaryFile(prefix="agdt-speckit-", suffix=".out", delete=False) as output_file:
+        output_path = output_file.name
+
+    env["GITHUB_OUTPUT"] = output_path
+    try:
+        _run_checked(["bash", str(script_path)] + args, env=env)
+        return _parse_key_value_file(output_path)
+    finally:
+        try:
+            os.unlink(output_path)
+        except OSError:
+            pass
+
+
+def _parse_key_value_file(path: str) -> dict[str, str]:
+    outputs: dict[str, str] = {}
+    file_path = Path(path)
+    if not file_path.exists():
+        return outputs
+
+    for line in file_path.read_text(encoding="utf-8").splitlines():
+        if "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        outputs[key.strip()] = value.strip()
+    return outputs
+
+
+def _commit_and_push_phase_branch(issue_number: int, spec_dir: str) -> None:
+    branch_name = f"speckit/{issue_number}/phase-1-specify"
+    _run_checked(["git", "config", "user.name", "github-actions[bot]"])
+    _run_checked(["git", "config", "user.email", "github-actions[bot]@users.noreply.github.com"])
+
+    remote_check = run_safe(
+        ["git", "ls-remote", "--exit-code", "--heads", "origin", branch_name],
+        capture_output=True,
+        text=True,
+        shell=False,
+    )
+    if remote_check.returncode == 0:
+        _run_checked(["git", "fetch", "origin", f"refs/heads/{branch_name}:refs/remotes/origin/{branch_name}"])
+        _run_checked(["git", "checkout", "-B", branch_name, f"origin/{branch_name}"])
+    elif remote_check.returncode == 2:
+        _run_checked(["git", "checkout", "-b", branch_name])
+    else:
+        stderr = remote_check.stderr.strip()
+        raise RuntimeError(
+            f"git ls-remote failed (rc={remote_check.returncode}): {stderr or 'unknown error'}"
+        )
+
+    _run_checked(["git", "add", spec_dir])
+    _run_checked(
+        [
+            "git",
+            "commit",
+            "-m",
+            f"spec(specify): Phase 1 artifacts for issue #{issue_number}\n\nRelates to #{issue_number}",
+        ]
+    )
+    _run_checked(["git", "push", "--force-with-lease", "-u", "origin", branch_name])
+
+
+def _create_phase_pull_request(issue: _IssueContext, spec_dir: str) -> None:
+    labels = json.dumps(issue.labels)
+    _run_script_with_outputs(
+        ".github/scripts/speckit-trigger/create-spec-pr.sh",
+        [
+            f"speckit/{issue.issue_number}/phase-1-specify",
+            spec_dir,
+            str(issue.issue_number),
+            issue.issue_title,
+            labels,
+            "--phase-number",
+            "1",
+            "--phase-name",
+            "specify",
+        ],
+    )
+
+
+def _run_checked(cmd: list[str], *, env: dict[str, str] | None = None) -> None:
+    result = run_safe(cmd, capture_output=True, text=True, shell=False, env=env)
+    if result.returncode != 0:
+        stderr = result.stderr.strip()
+        raise RuntimeError(stderr or f"command failed: {' '.join(cmd)}")
+
+
+def _require_repository() -> str:
+    repo = os.environ.get("GITHUB_REPOSITORY", "").strip()
+    if not repo:
+        raise RuntimeError("GITHUB_REPOSITORY is required")
+    return repo

agentic_devtools-0.2.88/specs/1432-standardize-copilot-review-response/analysis-report.md

@@ -0,0 +1,116 @@
+# Analysis Report: Standardize Copilot Review PR Response Process
+
+## Findings Table
+
+| ID | Category | Severity | Location(s) | Summary | Recommendation |
+|----|----------|----------|-------------|---------|----------------|
+| F-01 | G | HIGH | T058, T065 | T058 extends `run_ai_pr_loop()` with the full trigger→poll→resolve→squash sequence; T065 adds `run_full_trigger_loop()` in `trigger.py` coordinating the same trigger→poll→resolve→squash→push sequence | Clarify T065's scope — is it a reusable sub-orchestration called by T058, or a duplicate entry point? Add explicit dependency |
+| F-02 | G | HIGH | T026, T049, T050 | T026 tests `render_trigger_comment()` for FR-005/FR-006; T049 extends the same test file with an FR-003 suppressed-comments case and T050 adds an FR-005 failing-check-links case. All three target `test_render_trigger_comment.py` | T049/T050 are explicitly noted as extensions of T026 (1:1:1 compliance). Mark T049/T050 as dependent on T026 to avoid confusion |
+| F-03 | B | MEDIUM | Spec NFR-001 | "Complete within 10 minutes for a typical PR" — "typical PR" is not defined (LOC count, file count, check count) | Define "typical PR" with measurable bounds (e.g., ≤50 files changed, ≤5 check runs) |
+| F-04 | C | MEDIUM | T054 | `validate_workflow_yaml()` is underspecified — no definition of what constitutes "business logic" in YAML vs acceptable orchestration patterns | Define a concrete rule set (e.g., no `if` conditions on data, no string manipulation, no loops over data) |
+| F-05 | F | MEDIUM | Plan §3 vs Tasks T038/T040 | Plan shows `result_poller.poll_for_result_comment()` detecting agent output, but tasks introduce `await_copilot_session()` (T040) and `post_result_comment()` (T038) as intermediate steps not in the plan's flow diagram | Update plan's Module Interaction Flow to include `await_copilot_session()` → `post_result_comment()` before `poll_for_result_comment()` |
+| F-06 | C | MEDIUM | T059 | "Auth context management" is vague — no specific implementation pattern described (dependency injection, env var switching, token registry) | Specify whether this is a context manager, a provider parameter, or environment variable manipulation |
+| F-07 | B | MEDIUM | Spec FR-010 | Source issue/acceptance criteria require the Copilot SDK to receive the full PR changes and diff, but the spec only requires "changed file paths and selected hunks" — this is a source-artifact discrepancy, not just an ambiguous term | Align spec FR-010 with the source issue's full-diff requirement before implementation (e.g., replace "selected hunks" with "full unified diff of all changed files") |
+| F-08 | D | LOW | Spec | No explicit "Rollback Strategy" or "Monitoring/Alerting" section for production failure scenarios | Consider adding a brief operational runbook section for when the loop fails in production |
+| F-09 | E | LOW | NFR-005 (Audit logging) | NFR-005 requires structured audit events but only T062 covers it — no test task validates audit log output format | Add a test task for audit logging format validation |
+| F-10 | E | LOW | NFR-007 (Error messages) | NFR-007 requires "clear, actionable error messages" but no dedicated test task validates error message quality | Consider adding error message format tests to relevant modules |
+| F-11 | E | LOW | T008, T011, T015, T019, T021, T022, T023, T024 | 7 test tasks and 1 implementation task (T024: `Add NotImplementedError stubs`) lack both an explicit FR reference and a valid [USn] label, making them unmappable to requirements for coverage purposes | Add explicit FR-NNN references or [USn] labels to these tasks so they can be mapped to requirements |
+
+### Category G Structured Findings
+
+[
+  {
+    "id": "F-01",
+    "overlap_type": "overlapping",
+    "severity": "HIGH",
+    "task_ids": ["T058", "T065"],
+    "dimensions": ["description"],
+    "rationale": "T058 and T065 both describe trigger→poll→resolve→squash→push in different modules (orchestrator.py vs trigger.py). Description overlap only."
+  },
+  {
+    "id": "F-02",
+    "overlap_type": "overlapping",
+    "severity": "HIGH",
+    "task_ids": ["T026", "T049", "T050"],
+    "dimensions": ["file_path"],
+    "rationale": "T026/T049/T050 all target test_render_trigger_comment.py. T049/T050 extend T026 per 1:1:1. File path overlap only."
+  }
+]
+
+## Coverage Summary Table
+
+| Requirement Key | Has Task? | Task IDs | Notes |
+|----------------|-----------|----------|-------|
+| FR-001 | ✅ | T030, T032 | Trigger posting when both conditions met |
+| FR-002 | ✅ | T030, T032 | Guard against premature trigger |
+| FR-003 | ✅ | T025, T027, T051, T060 | Template selection + suppressed comments |
+| FR-004 | ✅ | T025, T027, T052 | CI-only template selection |
+| FR-005 | ✅ | T026, T028, T050, T052 | Check links in comments |
+| FR-006 | ✅ | T026, T028, T032 | @copilot prefix enforcement |
+| FR-007 | ✅ | T041, T042 | Reply to review comments |
+| FR-008 | ✅ | T041, T042 | Thread resolution via GraphQL |
+| FR-009 | ✅ | T045, T048 | Commit squash |
+| FR-010 | ✅ | T043, T044, T046, T047 | Commit message generation |
+| FR-011 | ✅ | T045, T048 | Force-push with human PAT |
+| FR-012 | ✅ | T029, T030, T031, T056, T057 | Deduplication detection |
+| FR-013 | ✅ | T053, T054, T058 | Logic in Python, not YAML |
+| FR-014 | ✅ | T033, T035, T037, T038, T039, T040 | Result comment detection |
+| FR-015 | ✅ | T025, T027 | Automatic template selection |
+| FR-016 | ✅ | T034, T036, T063 | Timeout failure handling |
+| FR-017 | ✅ | T045, T048 | SHA verification before push |
+| NFR-001 | ⚠️ | T058 (implicit) | T058 covers orchestration sequence only; no performance/timing validation for 10-minute budget |
+| NFR-002 | ✅ | T067, T068 | Retry configuration |
+| NFR-003 | ✅ | T069, T070 | 100% coverage validation |
+| NFR-004 | ✅ | T065, T066 | Idempotency |
+| NFR-005 | ✅ | T062 | Audit logging (no test task) |
+| NFR-006 | ✅ | T054, T055, T064 | YAML orchestration-only |
+| NFR-007 | ⚠️ | — | No dedicated task for error message validation |
+
+## Unmapped Tasks
+
+7 test tasks and 1 implementation task lack both an explicit FR reference and a valid `[USn]` label
+(finding key: `TASK:unmapped-test-task`, severity: LOW; reclassified here to cover both test and implementation tasks):
+
+- **Test tasks:** T008, T011, T015, T019, T021, T022, T023
+- **Implementation task:** T024 (`Add NotImplementedError stubs` — creates AzureDevOpsProvider stubs, not a test file)
+
+These tasks cannot be mapped to any requirement by the automated coverage tool. Adding explicit `FR-NNN` references or `[USn]` labels would integrate them into the coverage matrix.
+
+> **Note:** T049 has a valid `[US4]` label and T064, T065, T067, T069, T070 are mapped in the Coverage Summary Table above
+> (confirmed via contextual analysis and explicit requirement references in `tasks.md`).
+> These were excluded from the unmapped count.
+
+## Metrics
+
+| Metric | Value |
+|--------|-------|
+| Total Requirements | 24 (17 FR + 7 NFR) |
+| Total Tasks | 72 |
+| Coverage % | 92% (22/24 requirements have dedicated tasks) |
+| Ambiguity Count | 1 (F-03) |
+| Requirement Duplication Count (Category A) | 0 |
+| Source-Artifact Discrepancy Count | 1 (F-07) |
+| Critical Issues Count | 0 |
+| Task Deduplication Finding Count | 2 |
+| Task Deduplication by Type | duplicate: 0 / overlapping: 2 / conflicting: 0 |
+| Multi-Task Group Count | 1 (F-02 involves 3 tasks) |
+| Unmapped Task Count | 8 (7 test + 1 implementation) |
+
+## Next Actions
+
+1. **Resolve HIGH-severity findings (F-01, F-02):** Clarify task dependencies and sequencing for overlapping task groups to prevent implementer confusion.
+2. **Address MEDIUM-severity ambiguities (F-03, F-04, F-06):** Add concrete definitions for "typical PR", "business logic in YAML", and "auth context management" to the spec or plan.
+3. **Resolve source-artifact discrepancy (F-07):** Align spec FR-010 with the source issue's full-diff requirement — replace "selected hunks" with explicit full unified diff language before implementation.
+4. **Update plan flow diagram (F-05):** Add `await_copilot_session()` → `post_result_comment()` to the Module Interaction Flow before `poll_for_result_comment()`.
+5. **Consider LOW-severity enhancements (F-08–F-11):** Add operational runbook section, add audit/error-message test tasks, and add FR/USn labels to unmapped tasks (test and implementation).
+
+**Suggested commands:**
+
+- Run `/speckit.specify` with refinement to clarify ambiguities (F-03, F-04, F-06) and resolve source-artifact discrepancy (F-07)
+- Run `/speckit.plan` to update the Module Interaction Flow (F-05)
+- Manually edit `tasks.md` to add explicit dependency annotations for overlapping task groups (F-01, F-02)
+
+Would you like me to suggest concrete remediation edits for the top 2 issues (F-01, F-02)?
+
+---
+*Generated by Copilot SDK (claude-opus-4.6)*

{agentic_devtools-0.2.87 → agentic_devtools-0.2.88}/tests/unit/cli/ci/commands/test_ci_paths_golden_smoke.py

@@ -55,16 +55,7 @@ def _run_speckit_command(event_file: str, event_name: str, flag_value: str) -> d
         ("pull_request_opened.json", "pull_request", "ai", "golden_pull_request.json"),
         ("pull_request_review_submitted.json", "pull_request_review", "ai", "golden_pull_request_review.json"),
         ("workflow_run_completed.json", "workflow_run", "ai", "golden_workflow_run.json"),
-        pytest.param(
-            "issues_labeled.json",
-            "issues",
-            "speckit",
-            "golden_issues_labeled.json",
-            marks=pytest.mark.xfail(
-                reason="speckit_trigger_command is a stub (exit 11); parity test deferred to Phase 6",
-                strict=True,
-            ),
-        ),
+        ("issues_labeled.json", "issues", "speckit", "golden_issues_labeled.json"),
     ],
 )
 def test_legacy_and_python_paths_match_goldens(