issue-flow 0.5.2__tar.gz → 0.5.4__tar.gz

{issue_flow-0.5.2 → issue_flow-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: issue-flow
-Version: 0.5.2
+Version: 0.5.4
 Summary: Agents should behave. Let them follow the issue flow.
 Keywords: cursor,ai,agents,issue-tracking,workflow
 Author: jepegit

{issue_flow-0.5.2 → issue_flow-0.5.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "issue-flow"
-version = "0.5.2"
+version = "0.5.4"
 description = "Agents should behave. Let them follow the issue flow."
 readme = "README.md"
 license = "MIT"

{issue_flow-0.5.2 → issue_flow-0.5.4}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "issue-flow"
-version = "0.5.2"
+version = "0.5.4"
 description = "Agents should behave. Let them follow the issue flow."
 readme = "README.md"
 license = "MIT"

{issue_flow-0.5.2 → issue_flow-0.5.4}/src/issue_flow/agent.py

@@ -2,9 +2,9 @@
 
 These functions back ``issue-flow status`` (human-facing, top-level) and the
 ``issue-flow agent ...`` sub-commands (``state`` / ``preflight`` / ``switchback`` /
-``sync-branch`` / ``branches`` / ``version-plan`` / ``resolve`` / ``open-workspace`` /
-``worktree-add`` / ``worktree-list`` / ``worktree-remove`` / ``sweep`` /
-``archive`` / ``capture`` / ``sub-issue-add``) that exist so AI agents
+``default-sync`` / ``sync-branch`` / ``branches`` / ``version-plan`` / ``resolve`` /
+``open-workspace`` / ``worktree-add`` / ``worktree-list`` / ``worktree-remove`` /
+``sweep`` / ``archive`` / ``capture`` / ``sub-issue-add``) that exist so AI agents
 can ask the tool for a deterministic answer instead of re-deriving lifecycle
 state by hand on every run.
 
@@ -795,6 +795,7 @@ def run_switchback(project_root: Path, console: Console, as_json: bool) -> int:
         "pulled": False,
         "in_worktree": False,
         "dirty_paths": [],
+        "default_sync": None,
         "notes": notes,
     }
 
@@ -849,13 +850,24 @@ def run_switchback(project_root: Path, console: Console, as_json: bool) -> int:
 
     ok, error = gitutils.pull_ff_only(project_root)
     payload["pulled"] = ok
+    sync = gitutils.classify_default_sync(
+        project_root,
+        issueflows_dir=Settings().issueflows_dir,
+        default=default,
+        fetch=False,
+    )
+    payload["default_sync"] = sync
     if not ok:
         notes.append(
-            f"git pull --ff-only refused: {error} — reconcile manually before "
-            "continuing."
+            f"git pull --ff-only refused: {error} — do not rebase, force-push, "
+            "or push default to skip CI."
         )
+        notes.extend(_default_sync_note_lines(sync))
         return emit(1)
 
+    if sync.get("ahead"):
+        notes.extend(_default_sync_note_lines(sync))
+
     return emit(0)
 
 
@@ -878,6 +890,100 @@ def _render_switchback_text(
         console.print(f"  [{style}]{escape(note)}[/{style}]")
 
 
+# ---------------------------------------------------------------------------
+# agent default-sync (issue #303)
+# ---------------------------------------------------------------------------
+
+
+def run_default_sync(project_root: Path, console: Console, as_json: bool) -> int:
+    """Classify unique commits on home default vs origin — no mutate."""
+    notes: list[str] = []
+    if not gitutils.git_available():
+        payload = {
+            "default_branch": None,
+            "ahead": None,
+            "behind": None,
+            "ff_possible": False,
+            "class": "unknown",
+            "action": "unknown",
+            "commits": [],
+            "tree_paths": [],
+            "never": list(gitutils.DEFAULT_SYNC_NEVER),
+            "notes": ["git is not on PATH"],
+        }
+        if as_json:
+            _emit_json(console, payload)
+        else:
+            console.print("[red]error[/red]  git is not on PATH")
+        return 1
+
+    payload = gitutils.classify_default_sync(
+        project_root,
+        issueflows_dir=Settings().issueflows_dir,
+    )
+    notes.extend(payload.get("notes") or [])
+    payload["notes"] = notes
+    if as_json:
+        _emit_json(console, payload)
+        return 0
+    _render_default_sync_text(console, payload)
+    return 0
+
+
+def _default_sync_note_lines(sync: dict[str, Any]) -> list[str]:
+    """Short notes skills can print after an ff-only refusal or ahead-only home."""
+    lines = [
+        f"default-sync: action={sync.get('action')} class={sync.get('class')} "
+        f"ahead={sync.get('ahead')} behind={sync.get('behind')}"
+    ]
+    for commit in sync.get("commits") or []:
+        mark = " (merge)" if commit.get("is_merge") else ""
+        paths = ", ".join(commit.get("paths") or []) or "(no paths)"
+        lines.append(f"  {commit.get('sha')} {commit.get('subject')}{mark} — {paths}")
+    tree = sync.get("tree_paths") or []
+    if tree:
+        lines.append("  tree: " + ", ".join(tree))
+    action = sync.get("action")
+    if action == "tracking_pr":
+        lines.append(
+            "offer: merge origin/<default> or cherry-pick onto a chore branch, "
+            "then open a tiny PR — never push default directly."
+        )
+    elif action == "replay_tracking":
+        lines.append(
+            "offer: replay the tracking commit onto origin/<default> "
+            "(chore branch + PR). Do not stack another merge."
+        )
+    elif action == "stop_product":
+        lines.append(
+            "stop: unique commits touch product / lock / HISTORY. "
+            "User decides. Do not merge onto default."
+        )
+    elif action == "report_ahead":
+        lines.append(
+            "home default is ahead of origin; report unique commits. "
+            "Do not silent-push default."
+        )
+    elif action == "ff_only":
+        lines.append("ff-only is safe (behind only).")
+    never = sync.get("never") or list(gitutils.DEFAULT_SYNC_NEVER)
+    lines.append("never: " + "; ".join(never))
+    return lines
+
+
+def _render_default_sync_text(console: Console, payload: dict[str, Any]) -> None:
+    console.print(
+        f"[bold]action[/bold] {escape(str(payload.get('action')))}  "
+        f"class={escape(str(payload.get('class')))}  "
+        f"ahead={payload.get('ahead')} behind={payload.get('behind')}  "
+        f"ff_possible={payload.get('ff_possible')}"
+    )
+    for line in _default_sync_note_lines(payload)[1:]:
+        console.print(f"  {escape(line)}")
+    for note in payload.get("notes") or []:
+        console.print(f"  [dim]{escape(note)}[/dim]")
+
+
 # ---------------------------------------------------------------------------
 # agent sync-branch
 # ---------------------------------------------------------------------------
@@ -2809,7 +2915,15 @@ def run_workspace_update(
             f"`issue-flow workspace init` from the workspace root first."
         )
 
-    member_roots = workspace.member_roots()
+    seen_roots: set[Path] = set()
+    member_pairs: list[tuple[str, Path]] = []
+    for name, root in zip(workspace.members, workspace.member_roots(), strict=True):
+        resolved = root.resolve()
+        if resolved in seen_roots:
+            continue
+        seen_roots.add(resolved)
+        member_pairs.append((name, resolved))
+    member_roots = [root for _, root in member_pairs]
     if not member_roots:
         return _fail(
             f"no scaffolded member repos found under {workspace.root} — run "
@@ -2844,7 +2958,7 @@ def run_workspace_update(
     ok_count = 0
     fail_count = 0
 
-    for name, root in zip(workspace.members, member_roots, strict=True):
+    for name, root in member_pairs:
         entry: dict[str, Any] = {"name": name, "path": str(root)}
         try:
             _run_member_update(root)
@@ -2887,6 +3001,202 @@ def run_workspace_update(
     return 0 if fail_count == 0 else 1
 
 
+# ---------------------------------------------------------------------------
+# agent apply-changelog
+# ---------------------------------------------------------------------------
+
+
+def _status_path_for_issue(
+    project_root: Path, settings: Settings, number: int
+) -> Path | None:
+    """``issue<N>_status.md`` in current-issues, then solved (issue #288)."""
+    name = f"issue{number}_status.md"
+    base = project_root / settings.issueflows_dir
+    for folder in (settings.current_issues_folder, settings.solved_folder):
+        path = base / folder / name
+        if path.is_file():
+            return path
+    return None
+
+
+def run_apply_changelog(
+    project_root: Path,
+    console: Console,
+    issue_number: int,
+    as_json: bool,
+) -> int:
+    """Apply a deferred changelog bullet on the default branch (issue #288).
+
+    Reads ``### Deferred changelog`` from ``issue<N>_status.md`` (current, then
+    solved) and writes ``Settings.history_file``. Refuses on an issue branch.
+    No-op when the file is missing, the close step chose ``nohistory``, or the
+    bullet is already present.
+    """
+    from datetime import date
+
+    settings = Settings()
+    changelog_name = settings.history_file
+    notes: list[str] = []
+    payload: dict[str, Any] = {
+        "ok": False,
+        "action": "none",
+        "reason": None,
+        "issue": issue_number,
+        "history_file": changelog_name,
+        "status_file": None,
+        "bullet": None,
+        "planned_version": None,
+        "branch": None,
+        "default_branch": None,
+        "notes": notes,
+    }
+
+    def emit(exit_code: int) -> int:
+        payload["ok"] = exit_code == 0
+        if as_json:
+            _emit_json(console, payload)
+        else:
+            _render_apply_changelog_text(console, payload, exit_code)
+        return exit_code
+
+    if not gitutils.git_available():
+        notes.append("git is not available.")
+        payload["reason"] = "git_unavailable"
+        payload["action"] = "refused"
+        return emit(1)
+
+    current = gitutils.current_branch(project_root)
+    default = gitutils.default_branch(project_root)
+    payload["branch"] = current
+    payload["default_branch"] = default
+    if current is None or current != default:
+        notes.append(
+            f"apply-changelog runs on the default branch only "
+            f"(now on {current or 'detached'}, default {default})."
+        )
+        payload["reason"] = "not_default_branch"
+        payload["action"] = "refused"
+        return emit(1)
+
+    status_path = _status_path_for_issue(project_root, settings, issue_number)
+    if status_path is None:
+        notes.append(
+            f"no issue{issue_number}_status.md under "
+            f"{settings.current_issues_folder} or {settings.solved_folder}."
+        )
+        payload["reason"] = "no_status_file"
+        payload["action"] = "noop"
+        return emit(0)
+
+    payload["status_file"] = str(
+        status_path.relative_to(project_root)
+        if status_path.is_relative_to(project_root)
+        else status_path
+    )
+    try:
+        status_text = status_path.read_text(encoding="utf-8")
+    except OSError as exc:
+        notes.append(f"could not read status file: {exc}")
+        payload["reason"] = "status_unreadable"
+        payload["action"] = "refused"
+        return emit(1)
+
+    deferred = history.parse_deferred_changelog(status_text)
+    if deferred is None:
+        notes.append("no ### Deferred changelog section.")
+        payload["reason"] = "no_deferred_section"
+        payload["action"] = "noop"
+        return emit(0)
+    if deferred.skipped:
+        notes.append("deferred section is nohistory — skip.")
+        payload["reason"] = "nohistory"
+        payload["action"] = "noop"
+        return emit(0)
+    if not deferred.bullet:
+        notes.append("deferred section has no bullet.")
+        payload["reason"] = "no_bullet"
+        payload["action"] = "noop"
+        return emit(0)
+
+    payload["bullet"] = deferred.bullet
+    payload["planned_version"] = deferred.planned_version
+
+    history_path = project_root / changelog_name
+    if not history_path.is_file():
+        notes.append(f"no {changelog_name} at the project root — skip.")
+        payload["reason"] = "missing_history_file"
+        payload["action"] = "noop"
+        return emit(0)
+
+    try:
+        text = history_path.read_text(encoding="utf-8")
+    except OSError as exc:
+        notes.append(f"could not read {changelog_name}: {exc}")
+        payload["reason"] = "history_unreadable"
+        payload["action"] = "refused"
+        return emit(1)
+
+    if history.changelog_has_bullet(text, deferred.bullet):
+        notes.append("bullet already present.")
+        payload["reason"] = "already_present"
+        payload["action"] = "noop"
+        return emit(0)
+
+    try:
+        updated = history.append_unreleased_bullet(text, deferred.bullet)
+        action = "appended"
+        if deferred.planned_version:
+            updated = history.promote_unreleased(
+                updated, deferred.planned_version, date.today().isoformat()
+            )
+            action = "promoted"
+    except history.MissingUnreleased:
+        notes.append(f"{changelog_name} has no ## [Unreleased] heading.")
+        payload["reason"] = "no_unreleased_section"
+        payload["action"] = "refused"
+        return emit(1)
+
+    if updated == text:
+        notes.append("no change after apply.")
+        payload["reason"] = "unchanged"
+        payload["action"] = "noop"
+        return emit(0)
+
+    try:
+        history_path.write_text(updated, encoding="utf-8")
+    except OSError as exc:
+        notes.append(f"could not write {changelog_name}: {exc}")
+        payload["reason"] = "history_unwritable"
+        payload["action"] = "refused"
+        return emit(1)
+
+    payload["reason"] = action
+    payload["action"] = action
+    notes.append(f"wrote {changelog_name} ({action}).")
+    return emit(0)
+
+
+def _render_apply_changelog_text(
+    console: Console, payload: dict[str, Any], exit_code: int
+) -> None:
+    action = payload.get("action") or "none"
+    reason = payload.get("reason") or ""
+    issue = payload.get("issue")
+    if exit_code == 0:
+        console.print(
+            f"[green]ok[/green]  apply-changelog #{issue} "
+            f"[bold]{escape(str(action))}[/bold]"
+            + (f" ({escape(str(reason))})" if reason and reason != action else "")
+        )
+    else:
+        console.print(
+            f"[red]refused[/red]  apply-changelog #{issue}: "
+            f"{escape(str(reason) or action)}"
+        )
+    for note in payload.get("notes") or []:
+        console.print(f"  [dim]{escape(str(note))}[/dim]")
+
+
 # ---------------------------------------------------------------------------
 # agent sweep
 # ---------------------------------------------------------------------------
@@ -3531,7 +3841,8 @@ def _print_config_guide(console: Console, cfg_path: Path) -> None:
         "[bold]auto_close[/bold] / "
         "[bold]auto_plan[/bold] / [bold]auto_build[/bold] / "
         "[bold]early_pr[/bold] / [bold]fix_auto_name[/bold]; "
-        "[bold]confirm_version_bump[/bold] / [bold]confirm_changelog_update[/bold]; "
+        "[bold]confirm_version_bump[/bold] / [bold]confirm_changelog_update[/bold] / "
+        "[bold]defer_changelog[/bold]; "
         "[bold]ruff_autofix[/bold]; [bold]essential_tests[/bold] / "
         "[bold]test_runner[/bold] / [bold]essential_marker[/bold] / "
         "[bold]essential_review[/bold]: skill-behaviour toggles; re-run "

{issue_flow-0.5.2 → issue_flow-0.5.4}/src/issue_flow/cli.py

@@ -22,10 +22,10 @@ agent_app = typer.Typer(
         "Agent-facing helpers that read the .issueflows/ tree and git/gh so "
         "AI agents get deterministic answers instead of re-deriving lifecycle "
         "state by hand. All are read-only except `sweep`, `archive`, `capture`, "
-        "`switchback`, `sync-branch`, `pr-sync`, `repair`, `label-apply`, "
+        "`switchback`, `sync-branch`, `pr-sync`, `apply-changelog`, `repair`, `label-apply`, "
         "`open-workspace --open`, `worktree-add`, and `worktree-remove`. "
-        "`branches` (remote) and `local-branches` (local) only classify: "
-        "every delete stays in `/iflow-cleanup`."
+        "`branches` (remote), `local-branches` (local), and `default-sync` only classify: "
+        "every delete stays in `/iflow-cleanup`; `default-sync` never mutates."
     ),
 )
 
@@ -263,10 +263,26 @@ def update(
     json_output: bool = typer.Option(
         False, "--json", help="Emit a machine-readable JSON object (with --all)."
     ),
+    include_workspace: bool = typer.Option(
+        False,
+        "--workspace",
+        help=(
+            "With --all, also union members of the nearest "
+            "issueflow-workspace.toml (unique by resolved path). "
+            "Without --all this flag is an error."
+        ),
+    ),
 ) -> None:
     """Refresh packaged editor commands, rules, and workflow doc from this package."""
     from issue_flow.init import run_update, run_update_all
 
+    if include_workspace and not all_roots:
+        _console.print(
+            "[red]error[/red]  --workspace requires --all "
+            "(union registry + nearest workspace members)."
+        )
+        raise typer.Exit(code=2)
+
     if all_roots:
         raise typer.Exit(
             code=run_update_all(
@@ -274,6 +290,8 @@ def update(
                 editors=editor,
                 force=force,
                 as_json=json_output,
+                include_workspace=include_workspace,
+                workspace_start=project_dir,
             )
         )
 
@@ -522,6 +540,25 @@ def agent_switchback(
     raise typer.Exit(code=run_switchback(project_dir, _console, json_output))
 
 
+@agent_app.command("default-sync")
+def agent_default_sync(
+    project_dir: Path = _PROJECT_DIR_OPTION,
+    json_output: bool = typer.Option(
+        False, "--json", help="Emit a machine-readable JSON object."
+    ),
+) -> None:
+    """Classify unique commits on home default vs origin (no mutate).
+
+    The mechanical half of pick / cleanup / switchback recovery when
+    ``git pull --ff-only`` cannot reconcile unpushed home commits with a
+    squash on origin. Prints ahead/behind, commit onelines + paths, and a
+    recommended ``action``. Never rebases, force-pushes, or pushes default.
+    """
+    from issue_flow.agent import run_default_sync
+
+    raise typer.Exit(code=run_default_sync(project_dir, _console, json_output))
+
+
 @agent_app.command("sync-branch")
 def agent_sync_branch(
     project_dir: Path = _PROJECT_DIR_OPTION,
@@ -552,6 +589,35 @@ def agent_sync_branch(
     raise typer.Exit(code=run_sync_branch(project_dir, _console, strategy, json_output))
 
 
+@agent_app.command("apply-changelog")
+def agent_apply_changelog(
+    issue: int = typer.Option(
+        ...,
+        "--issue",
+        "-n",
+        help="GitHub issue number whose deferred changelog bullet to apply.",
+    ),
+    project_dir: Path = _PROJECT_DIR_OPTION,
+    json_output: bool = typer.Option(
+        False, "--json", help="Emit a machine-readable JSON object."
+    ),
+) -> None:
+    """Apply a deferred changelog bullet on the default branch.
+
+    Reads ``### Deferred changelog`` from ``issue<N>_status.md`` (current, then
+    solved) and writes the project's HISTORY/CHANGELOG file. Refuses unless
+    the checkout is on the default branch. No-op when the file is missing,
+    the close step chose ``nohistory``, or the bullet is already present.
+    Used by ``/iflow-cleanup`` and yolo post-pull when ``defer_changelog`` is
+    on (issue #288).
+    """
+    from issue_flow.agent import run_apply_changelog
+
+    raise typer.Exit(
+        code=run_apply_changelog(project_dir, _console, issue, json_output)
+    )
+
+
 @agent_app.command("pr-sync")
 def agent_pr_sync(
     numbers: list[int] = typer.Argument(
@@ -1201,6 +1267,7 @@ def config_add(
     ``confirm_version_bump``,
     ``ruff_autofix``, ``auto_close``, ``auto_plan``, ``auto_build``,
     ``early_pr``, ``fix_auto_name``, ``confirm_changelog_update``,
+    ``defer_changelog``,
     ``essential_tests``, ``test_runner``, ``essential_marker``,
     ``essential_review``, ``pstack_skills``
     — taking each from its ``ISSUEFLOW_*`` env var when set, else the default.
@@ -1427,7 +1494,10 @@ def workspace_update(
 def register(
     project_dir: Path = typer.Argument(
         default=Path("."),
-        help="Project root to add to the user-global registry.",
+        help=(
+            "Project root to add, or the walk start when ``--discover`` "
+            "is set (defaults to current directory)."
+        ),
         exists=True,
         file_okay=False,
         resolve_path=True,
@@ -1435,10 +1505,89 @@ def register(
     json_output: bool = typer.Option(
         False, "--json", help="Emit a machine-readable JSON object."
     ),
+    discover: bool = typer.Option(
+        False,
+        "--discover",
+        help=(
+            "Walk PROJECT_DIR for existing issue-flow scaffolds and offer "
+            "to register them. Never runs from update --all / init / "
+            "workspace update."
+        ),
+    ),
+    yes: bool = typer.Option(
+        False,
+        "--yes",
+        help="With --discover, register candidates without a confirm prompt.",
+    ),
+    max_depth: int = typer.Option(
+        4,
+        "--max-depth",
+        help="With --discover, maximum directory depth below PROJECT_DIR.",
+    ),
 ) -> None:
     """Add a project root to the user-global registry for ``update --all``."""
+    from issue_flow.config import Settings
+    from issue_flow.project import discover_issueflow_roots
     from issue_flow.user_global import register_root, user_global_registry_path
 
+    if discover:
+        if max_depth < 0:
+            _console.print("[red]error[/red]  --max-depth must be >= 0")
+            raise typer.Exit(code=2)
+        settings = Settings()
+        candidates = discover_issueflow_roots(
+            project_dir,
+            issueflows_dir=settings.issueflows_dir,
+            max_depth=max_depth,
+        )
+        if not yes:
+            _console.print(
+                f"[bold]{len(candidates)} scaffold(s) under {project_dir}[/bold]"
+            )
+            for root in candidates:
+                _console.print(f"  {root}")
+            if not candidates:
+                payload = {
+                    "ok": True,
+                    "discover": True,
+                    "candidates": [],
+                    "added": [],
+                    "already": [],
+                    "registry": str(user_global_registry_path()),
+                }
+                if json_output:
+                    _console.print_json(data=payload)
+                else:
+                    _console.print("[dim]nothing to register[/dim]")
+                return
+            if not typer.confirm("Register these roots?", default=False):
+                raise typer.Exit(code=1)
+        added_paths: list[str] = []
+        already_paths: list[str] = []
+        for root in candidates:
+            if register_root(root):
+                added_paths.append(str(root))
+            else:
+                already_paths.append(str(root))
+        payload = {
+            "ok": True,
+            "discover": True,
+            "candidates": [str(root) for root in candidates],
+            "added": added_paths,
+            "already": already_paths,
+            "registry": str(user_global_registry_path()),
+        }
+        if json_output:
+            _console.print_json(data=payload)
+            return
+        for path in added_paths:
+            _console.print(f"[green]registered[/green]  {path}")
+        for path in already_paths:
+            _console.print(f"[dim]already registered[/dim]  {path}")
+        if not candidates:
+            _console.print("[dim]nothing to register[/dim]")
+        return
+
     added = register_root(project_dir)
     payload = {
         "ok": True,

{issue_flow-0.5.2 → issue_flow-0.5.4}/src/issue_flow/config.py

@@ -18,6 +18,7 @@ from issue_flow.modes import (
     DEFAULT_AUTO_PLAN,
     DEFAULT_CHECKS_WATCH_MINUTES,
     DEFAULT_CONFIRM_CHANGELOG_UPDATE,
+    DEFAULT_DEFER_CHANGELOG,
     DEFAULT_EARLY_PR,
     DEFAULT_FIX_AUTO_NAME,
     DEFAULT_LOCKED,
@@ -616,6 +617,16 @@ class Settings:
             ),
         )
 
+    def resolve_defer_changelog(self, project_root: Path) -> bool:
+        """Resolve whether changelog writes wait until the default branch after merge."""
+        persisted = modes_module.read_defer_changelog(self.config_path(project_root))
+        if persisted is not None:
+            return persisted
+        return self.user_global_or(
+            "defer_changelog",
+            _env_flag("ISSUEFLOW_DEFER_CHANGELOG", default=DEFAULT_DEFER_CHANGELOG),
+        )
+
     def resolve_essential_tests(self, project_root: Path) -> bool:
         """Resolve whether essential-tests skill hooks are enabled."""
         persisted = modes_module.read_essential_tests(self.config_path(project_root))
@@ -828,6 +839,9 @@ class Settings:
                 "ISSUEFLOW_CONFIRM_CHANGELOG_UPDATE",
                 default=DEFAULT_CONFIRM_CHANGELOG_UPDATE,
             ),
+            "defer_changelog": _env_flag(
+                "ISSUEFLOW_DEFER_CHANGELOG", default=DEFAULT_DEFER_CHANGELOG
+            ),
             "essential_tests": _env_flag(
                 "ISSUEFLOW_ESSENTIAL_TESTS", default=DEFAULT_ESSENTIAL_TESTS
             ),
@@ -882,6 +896,7 @@ class Settings:
             "confirm_changelog_update": self.resolve_confirm_changelog_update(
                 project_root
             ),
+            "defer_changelog": self.resolve_defer_changelog(project_root),
             "essential_tests": self.resolve_essential_tests(project_root),
             "test_runner": self.resolve_test_runner(project_root),
             "essential_marker": self.resolve_essential_marker(project_root),
@@ -972,6 +987,7 @@ class Settings:
             "confirm_changelog_update": self.resolve_confirm_changelog_update(
                 project_root
             ),
+            "defer_changelog": self.resolve_defer_changelog(project_root),
             "essential_tests": self.resolve_essential_tests(project_root),
             "test_runner": self.resolve_test_runner(project_root),
             "essential_marker": self.resolve_essential_marker(project_root),