agentwire-dev 1.55.0__tar.gz → 1.56.0__tar.gz

{agentwire_dev-1.55.0 → agentwire_dev-1.56.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentwire-dev
-Version: 1.55.0
+Version: 1.56.0
 Summary: Multi-session voice web interface for AI coding agents
 Project-URL: Homepage, https://agentwire.dev
 Project-URL: Repository, https://github.com/dotdevdotdev/agentwire-dev

{agentwire_dev-1.55.0 → agentwire_dev-1.56.0}/agentwire/__init__.py

@@ -1,3 +1,3 @@
 """AgentWire - Multi-session voice web interface for AI coding agents."""
 
-__version__ = "1.55.0"
+__version__ = "1.56.0"

{agentwire_dev-1.55.0 → agentwire_dev-1.56.0}/agentwire/__main__.py

@@ -268,6 +268,17 @@ Command Categories:
         "stop", help="Kill the sitting's sessions (prompt history kept)"
     )
     c_stop.add_argument("--name", help=_name_help)
+    c_stop.add_argument(
+        "--minutes", dest="minutes", action="store_true", default=None,
+        help="Render the minutes artifact (default: render when any prompt exists)",
+    )
+    c_stop.add_argument(
+        "--no-minutes", dest="minutes", action="store_false",
+        help="Skip the minutes artifact",
+    )
+    c_stop.add_argument(
+        "--synthesis", help="Synthesis for the minutes: text, or a path to a file"
+    )
     c_stop.add_argument("--json", action="store_true", help="Output JSON")
     c_stop.set_defaults(func=council_cli.cmd_council_stop)
 
@@ -332,6 +343,30 @@ Command Categories:
     c_reply.add_argument("--json", action="store_true", help="Output JSON")
     c_reply.set_defaults(func=council_cli.cmd_council_reply)
 
+    # council minutes
+    c_minutes = council_subparsers.add_parser(
+        "minutes",
+        help="Render a sitting's minutes artifact (question + takes + synthesis)",
+        description=(
+            "Deterministically renders the sitting's persisted prompt history "
+            "(question + attributed verbatim take/ack/pass replies) plus an "
+            "optional orchestrator-supplied synthesis into a self-contained "
+            "HTML artifact at ~/.agentwire/artifacts/council-<name>-minutes/, "
+            "and opens it as a portal artifact window when the portal is up. "
+            "Works for live and dismissed sittings (prompt history is kept "
+            "on stop)."
+        ),
+    )
+    c_minutes.add_argument("--name", help=_name_help)
+    c_minutes.add_argument(
+        "--prompt", help="Prompt id to render, or 'all' (default: all)"
+    )
+    c_minutes.add_argument(
+        "--synthesis", help="Synthesis: text, or a path to a file containing it"
+    )
+    c_minutes.add_argument("--json", action="store_true", help="Output JSON")
+    c_minutes.set_defaults(func=council_cli.cmd_council_minutes)
+
     return parser
 
 

{agentwire_dev-1.55.0 → agentwire_dev-1.56.0}/agentwire/channels_cli.py

@@ -57,9 +57,11 @@ def _infer_session_from_path() -> str | None:
 
     ~/projects/myapp -> myapp
     ~/projects/myapp-worktrees/feature -> myapp/feature
+    ~/worktrees/myapp/fix-bug -> myapp-fix-bug (worktree session)
     """
     cwd = Path.cwd()
     projects_dir = Path.home() / "projects"
+    worktrees_dir = Path.home() / "worktrees"
 
     try:
         rel = cwd.relative_to(projects_dir)
@@ -76,6 +78,15 @@ def _infer_session_from_path() -> str | None:
     except ValueError:
         pass
 
+    try:
+        # Worktree sessions live at ~/worktrees/<project>/<name>/ with a flat
+        # tmux session name {project}-{name}.
+        parts = cwd.relative_to(worktrees_dir).parts
+        if len(parts) >= 2:
+            return f"{parts[0]}-{parts[1]}"
+    except ValueError:
+        pass
+
     return None
 
 

{agentwire_dev-1.55.0 → agentwire_dev-1.56.0}/agentwire/config.py

@@ -84,7 +84,16 @@ class ServerConfig:
 
 @dataclass
 class WorktreesConfig:
-    """Git worktrees configuration for parallel sessions."""
+    """Git worktrees configuration for `project/branch` sessions.
+
+    Governs the legacy ``project/branch`` session layout under
+    ``~/projects/<project>-worktrees/``. Still ALIVE (#703): the scheduler's
+    worktree+PR dispatch creates its sessions via
+    ``agentwire new -s <project>/<branch>``, and ``copy_files`` seeds every
+    fresh worktree (including scheduler dispatches). Standalone
+    ``agentwire worktree`` sessions use :class:`WorktreeConfig` instead
+    (``~/worktrees/<project>/<name>/``).
+    """
 
     enabled: bool = True
     suffix: str = "-worktrees"
@@ -128,7 +137,9 @@ class WorktreeConfig:
         default_project: Repo path used when ``--project`` is omitted and
             cwd is not inside a git repo. ``None`` → infer from cwd's git
             root, else cwd.
-        worktree_dir: Where worktrees live (one dir per session).
+        worktree_dir: Root under which worktrees are created, nested per
+            project — ``<worktree_dir>/<project>/<name>/`` — mirroring
+            ``~/projects/<project>/``.
         naming: Optional branch-name template applied in default (new-branch)
             mode, e.g. ``"{user}/{slug}"`` or ``"feature-{slug}"``.
             Placeholders: ``{name}`` (raw), ``{slug}`` (slugified),

{agentwire_dev-1.55.0 → agentwire_dev-1.56.0}/agentwire/council/cli.py

@@ -16,12 +16,15 @@ recency) otherwise, and **every command echoes which sitting it acted on**.
 Subcommands:
 
 - ``start``   — spin up the orchestrator + lens soul sessions (a *sitting*)
-- ``stop``    — kill the sitting's sessions, clear state (history kept)
+- ``stop``    — kill the sitting's sessions, clear state (history kept);
+  renders the minutes artifact by default when any prompt exists (#708)
 - ``status``  — sitting + per-session liveness + open prompts
 - ``ask``     — fan a prompt out to every soul (creates the inbox first)
 - ``collect`` — block until every soul has filed take/ack/pass, or timeout
 - ``reply``   — file a soul's reply (souls run this via Bash)
 - ``list``    — every live/known sitting, oldest-first
+- ``minutes`` — render a sitting's persisted record to a standalone HTML
+  artifact (question + attributed verbatim takes + optional synthesis)
 """
 
 from __future__ import annotations
@@ -30,9 +33,10 @@ import json
 import subprocess
 import sys
 from datetime import datetime, timezone
+from pathlib import Path
 from typing import Any
 
-from agentwire.council import inbox, state
+from agentwire.council import inbox, state, view
 
 # --- output helpers -----------------------------------------------------------
 
@@ -160,6 +164,35 @@ def current_session() -> str | None:
     return pane_manager.get_current_session()
 
 
+def open_artifact_window(url: str, title: str) -> bool:
+    """Best-effort: open a rendered artifact as a portal window.
+
+    Returns True only when the portal accepted the open; a down or erroring
+    portal returns False — the artifact file exists on disk either way.
+    """
+    import os
+
+    from agentwire import core
+
+    portal = os.environ.get("AGENTWIRE_PORTAL_URL")
+    if not portal:
+        try:
+            portal = (core.load_config().get("portal", {}) or {}).get("url")
+        except Exception:
+            portal = None
+    portal = portal or core._default_portal_url()
+    try:
+        resp = core.portal_request(
+            "POST",
+            f"{portal}/api/desktop/window/open",
+            json={"type": "artifact", "url": url, "title": title},
+            timeout=5,
+        )
+        return resp.status_code == 200 and bool(resp.json().get("success"))
+    except Exception:
+        return False
+
+
 # --- targeting / resolution -----------------------------------------------------
 
 
@@ -322,6 +355,39 @@ def cmd_council_start(args) -> int:
     return _emit(args, payload, human, exit_code=0 if payload["success"] else 1, council=name)
 
 
+def _synthesis_text(value: str | None) -> str:
+    """Resolve ``--synthesis <file-or-text>``: an existing file's content,
+    else the value verbatim."""
+    if not value:
+        return ""
+    try:
+        path = Path(value).expanduser()
+        if path.is_file():
+            return path.read_text()
+    except (OSError, ValueError):
+        pass  # not a readable path — the value is the synthesis itself
+    return value
+
+
+def _render_minutes(
+    name: str, prompt_ids: list[int] | None = None, synthesis: str = ""
+) -> tuple[str | None, bool | None]:
+    """Write the minutes artifact and best-effort open it in the portal.
+
+    Returns ``(path, opened)`` — both None when the sitting has no matching
+    prompt history (nothing rendered, nothing opened).
+    """
+    from agentwire.council import minutes
+
+    path = minutes.write_minutes(name, prompt_ids, synthesis=synthesis)
+    if path is None:
+        return None, None
+    opened = open_artifact_window(
+        minutes.artifact_url(name), f"Council minutes — {name}"
+    )
+    return str(path), opened
+
+
 def cmd_council_stop(args) -> int:
     name, err = resolve_name(args)
     if err:
@@ -330,6 +396,15 @@ def cmd_council_stop(args) -> int:
     if sitting is None:
         return _emit_error(args, f"no council sitting '{name}'")
 
+    # Minutes before teardown (#708): tri-state --minutes/--no-minutes,
+    # default (None) renders exactly when any prompt history exists.
+    minutes_path: str | None = None
+    minutes_opened: bool | None = None
+    if getattr(args, "minutes", None) is not False:
+        minutes_path, minutes_opened = _render_minutes(
+            name, synthesis=_synthesis_text(getattr(args, "synthesis", None))
+        )
+
     live = list_live_sessions()
     killed: list[str] = []
     not_running: list[str] = []
@@ -340,14 +415,57 @@ def cmd_council_stop(args) -> int:
             not_running.append(session)
     state.clear_sitting(name)
 
-    payload = {"success": True, "killed": killed, "not_running": not_running}
-    return _emit(
-        args,
-        payload,
-        f"Council '{name}' stopped ({len(killed)} sessions killed). Prompt history kept.",
-        council=name,
+    payload = {
+        "success": True,
+        "killed": killed,
+        "not_running": not_running,
+        "minutes": minutes_path,
+        "minutes_opened": minutes_opened,
+    }
+    human = (
+        f"Council '{name}' stopped ({len(killed)} sessions killed). "
+        "Prompt history kept."
+    )
+    if minutes_path:
+        human += f"\nMinutes: {minutes_path}"
+    return _emit(args, payload, human, council=name)
+
+
+def cmd_council_minutes(args) -> int:
+    name, err = resolve_name(args)
+    if err:
+        return _emit_error(args, err)
+
+    available = view.available_prompt_ids(name)
+    if not available:
+        return _emit_error(args, f"council '{name}' has no prompt history to render")
+
+    prompt_arg = getattr(args, "prompt", None) or "all"
+    prompt_ids: list[int] | None = None
+    if str(prompt_arg) != "all":
+        try:
+            prompt_ids = [int(prompt_arg)]
+        except (TypeError, ValueError):
+            return _emit_error(
+                args, f"--prompt must be a prompt id or 'all', got {prompt_arg!r}"
+            )
+        if prompt_ids[0] not in available:
+            return _emit_error(
+                args,
+                f"no prompt #{prompt_ids[0]} in council '{name}' "
+                f"(available: {', '.join(map(str, available))})",
+            )
+
+    path, opened = _render_minutes(
+        name, prompt_ids, synthesis=_synthesis_text(getattr(args, "synthesis", None))
     )
 
+    payload = {"success": True, "path": path, "opened": opened}
+    human = f"Minutes: {path}"
+    if opened:
+        human += "\nOpened as a portal artifact window."
+    return _emit(args, payload, human, council=name)
+
 
 def cmd_council_status(args) -> int:
     name, err = resolve_name(args)

agentwire_dev-1.56.0/agentwire/council/minutes.py

@@ -0,0 +1,174 @@
+"""Council minutes — deterministic HTML render of a sitting's persisted record.
+
+Handoff pattern (#708): everything verbatim (the question, the attributed
+take/ack/pass replies) already persists under
+``~/.agentwire/council/<name>/prompts/NNNN/``, so the renderer is a pure
+function of disk state. The synthesis exists only in the orchestrator's
+context, so it arrives as an *input* — omitted, the minutes render without a
+synthesis section.
+
+Output is one fully self-contained HTML file (inline CSS only — the portal's
+artifact CSP blocks external fetches), theme-aware via
+``prefers-color-scheme``, at::
+
+    ~/.agentwire/artifacts/council-<name>-minutes/index.html
+
+Works for live and dismissed sittings alike — prompt history is disk-derived,
+sitting metadata falls back from ``sitting.json`` to the preserved
+``archive.json``.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+import jinja2
+
+from agentwire.council import inbox, state, view
+
+# --- paths ------------------------------------------------------------------
+
+
+def artifacts_dir() -> Path:
+    """The portal artifacts root (config override honored)."""
+    try:
+        from agentwire.config import load_config
+
+        return Path(str(load_config().artifacts.dir)).expanduser()
+    except Exception:
+        return Path.home() / ".agentwire" / "artifacts"
+
+
+def minutes_path(name: str) -> Path:
+    return artifacts_dir() / f"council-{name}-minutes" / "index.html"
+
+
+def artifact_url(name: str) -> str:
+    """Path relative to the artifacts root — what the portal iframe loads."""
+    return f"council-{name}-minutes/index.html"
+
+
+# --- gather -----------------------------------------------------------------
+
+
+def _fmt_ts(iso: str) -> str:
+    """ISO timestamp → compact display form (``2026-07-04 15:38 UTC``)."""
+    if not iso:
+        return ""
+    try:
+        dt = datetime.fromisoformat(iso)
+    except (ValueError, TypeError):
+        return iso
+    suffix = " UTC" if dt.tzinfo is not None else ""
+    return dt.strftime("%Y-%m-%d %H:%M") + suffix
+
+
+def gather(name: str, prompt_ids: list[int] | None = None) -> dict | None:
+    """Collect a sitting's persisted record into a render-ready dict.
+
+    ``prompt_ids`` filters to specific rounds (None = every prompt on disk).
+    Returns ``None`` when nothing matches — a sitting that never deliberated
+    has no minutes. Reply dicts carry only content (soul, kind, text,
+    timestamp), never local filesystem paths: the artifact is built to be
+    shared.
+    """
+    available = view.available_prompt_ids(name)
+    selected = (
+        available if prompt_ids is None else [p for p in prompt_ids if p in available]
+    )
+    if not selected:
+        return None
+
+    sitting = state.read_sitting(name)
+    archived = sitting is None
+    dismissed_at = ""
+    if archived:
+        raw = state.read_archive_dict(name)
+        dismissed_at = (raw or {}).get("dismissed_at", "")
+        sitting = (
+            state.Sitting.from_dict(raw)
+            if raw is not None
+            else state.Sitting(
+                orchestrator=state.orchestrator_for(name),
+                roster=[],
+                sessions={},
+                started_at="",
+            )
+        )
+
+    prompts = []
+    for pid in selected:
+        meta = inbox.read_meta(name, pid)
+        try:
+            question = (inbox.prompt_dir(name, pid) / "prompt.md").read_text()
+        except OSError:
+            question = ""
+        replies = [
+            {
+                "soul": r.soul,
+                "kind": r.kind,
+                "text": r.text.strip(),
+                "written_at": _fmt_ts(r.written_at),
+            }
+            for r in inbox.list_replies(name, pid)
+        ]
+        prompts.append(
+            {
+                "id": pid,
+                "question": question.strip(),
+                "created_at": _fmt_ts(meta.get("created_at", "")),
+                "roster": meta.get("roster") or list(sitting.roster),
+                "replies": replies,
+            }
+        )
+
+    roster = list(sitting.roster) or prompts[0]["roster"]
+    return {
+        "name": name,
+        "archived": archived,
+        "started_at": _fmt_ts(sitting.started_at),
+        "dismissed_at": _fmt_ts(dismissed_at),
+        "roster": roster,
+        "prompts": prompts,
+    }
+
+
+# --- render -----------------------------------------------------------------
+
+
+def _env() -> jinja2.Environment:
+    # autoescape=True explicitly: select_autoescape keys off the *final*
+    # extension, and ``.html.j2`` ends in ``.j2`` — verbatim soul takes are
+    # untrusted content, so escaping must never silently switch off.
+    templates = Path(__file__).resolve().parent.parent / "templates"
+    return jinja2.Environment(
+        loader=jinja2.FileSystemLoader(str(templates)),
+        autoescape=True,
+    )
+
+
+def render_html(record: dict, synthesis: str = "") -> str:
+    template = _env().get_template("council/minutes.html.j2")
+    return template.render(
+        record=record,
+        synthesis=(synthesis or "").strip(),
+        generated_at=_fmt_ts(state.now_iso()),
+    )
+
+
+def write_minutes(
+    name: str, prompt_ids: list[int] | None = None, synthesis: str = ""
+) -> Path | None:
+    """Render and write the minutes artifact; return its path.
+
+    Returns ``None`` (writes nothing) when the sitting has no matching prompt
+    history — a zero-prompt sitting leaves no minutes behind.
+    """
+    record = gather(name, prompt_ids)
+    if record is None:
+        return None
+    out = minutes_path(name)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(render_html(record, synthesis), encoding="utf-8")
+    return out

{agentwire_dev-1.55.0 → agentwire_dev-1.56.0}/agentwire/mcp_council.py

@@ -52,25 +52,37 @@ def council_start(name: str = "", roster: str = "", model: str = "") -> str:
 
 
 @mcp.tool()
-def council_stop(name: str = "") -> str:
+def council_stop(name: str = "", minutes: bool = True, synthesis: str = "") -> str:
     """Stop a council sitting: kill all soul sessions + the orchestrator.
 
-    Prompt history under ``~/.agentwire/council/<name>/prompts/`` is kept.
+    Prompt history under ``~/.agentwire/council/<name>/prompts/`` is kept, and
+    by default the sitting's minutes artifact is rendered on the way out
+    (when any prompt exists) — pass your synthesis so the record includes it.
 
     Args:
         name: Sitting name (empty = cwd-repo-slug / sole live sitting)
+        minutes: Render the minutes artifact (default True; skipped anyway
+            when the sitting has no prompt history)
+        synthesis: Your synthesis for the minutes — text, or a path to a file
 
     Returns:
-        Which sessions were killed.
+        Which sessions were killed, plus the minutes path when rendered.
     """
     args = ["council", "stop"]
     if name:
         args += ["--name", name]
+    if not minutes:
+        args += ["--no-minutes"]
+    if synthesis:
+        args += ["--synthesis", synthesis]
     data = run_agentwire_cmd(args, timeout=60)
     if not data.get("success"):
         return f"Failed to stop council: {data.get('error', 'Unknown error')}"
     killed = data.get("killed") or []
-    return f"{_council_tag(data)}Council stopped. Killed: {', '.join(killed) or '(none)'}"
+    out = f"{_council_tag(data)}Council stopped. Killed: {', '.join(killed) or '(none)'}"
+    if data.get("minutes"):
+        out += f"\nMinutes: {data['minutes']}"
+    return out
 
 
 @mcp.tool()
@@ -191,3 +203,38 @@ def council_collect(prompt_id: int = 0, timeout: int = 120, name: str = "") -> s
     for r in data.get("replies") or []:
         lines.append(f"\n--- {r['soul']} ({r['kind']}) ---\n{r['text']}")
     return "\n".join(lines)
+
+
+@mcp.tool()
+def council_minutes(name: str = "", prompt: str = "", synthesis: str = "") -> str:
+    """Render a sitting's minutes: question, synthesis, verbatim takes → HTML.
+
+    Deterministically renders the sitting's persisted prompt history
+    (question + attributed take/ack/pass replies) plus your optional
+    synthesis into a self-contained HTML artifact at
+    ``~/.agentwire/artifacts/council-<name>-minutes/index.html``, and opens
+    it as a portal artifact window when the portal is up. Works for live and
+    dismissed sittings alike — prompt history survives ``council_stop``.
+
+    Args:
+        prompt: Prompt id to render, or 'all' (empty = all)
+        synthesis: Your synthesis of the takes — text, or a path to a file
+        name: Sitting name (empty = cwd-repo-slug / sole live sitting)
+
+    Returns:
+        The rendered artifact's path, and whether a portal window opened.
+    """
+    args = ["council", "minutes"]
+    if name:
+        args += ["--name", name]
+    if prompt:
+        args += ["--prompt", prompt]
+    if synthesis:
+        args += ["--synthesis", synthesis]
+    data = run_agentwire_cmd(args, timeout=60)
+    if not data.get("success"):
+        return f"Failed to render minutes: {data.get('error') or data}"
+    out = f"{_council_tag(data)}Minutes: {data.get('path')}"
+    if data.get("opened"):
+        out += "\nOpened as a portal artifact window."
+    return out

{agentwire_dev-1.55.0 → agentwire_dev-1.56.0}/agentwire/mcp_worktree.py

@@ -19,9 +19,9 @@ def worktree_create(
 
     The spawn half of the worktree lifecycle (paired with worktree_status /
     worktree_list / worktree_remove). Creates a branch off origin/<base>, a
-    worktree under ~/worktrees/, and a tmux session running an agent with the
-    worktree-session safety etiquette auto-injected. This is how a Briefing Mode
-    anchor fans out correspondents.
+    worktree at ~/worktrees/<project>/<name>/, and a tmux session running an
+    agent with the worktree-session safety etiquette auto-injected. This is how
+    a Briefing Mode anchor fans out correspondents.
 
     Args:
         name: Worktree/branch name (becomes the branch + session suffix).

{agentwire_dev-1.55.0 → agentwire_dev-1.56.0}/agentwire/project_config.py

@@ -5,6 +5,7 @@ This file lives in project directories and is the source of truth for session co
 """
 
 import subprocess
+import sys
 from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
@@ -138,6 +139,47 @@ def compose_session_type(harness: str, posture: str) -> str:
     return harness
 
 
+@dataclass
+class WorktreeOverrides:
+    """Per-project overrides for `agentwire worktree` (the `worktree:` block).
+
+    Sits between per-invocation flags and the global config in the
+    precedence chain (#705): CLI/MCP flag → this block → global `worktree:`
+    in config.yaml → built-ins. ``dir`` only moves the root — the nesting
+    shape is unchanged: ``<dir>/<project>/<name>/``.
+    """
+    dir: Optional[Path] = None   # overrides worktree.worktree_dir for this project
+    base: Optional[str] = None   # overrides worktree.default_base for this project
+
+
+_WORKTREE_OVERRIDE_KEYS = {"dir", "base"}
+
+
+def _parse_worktree_overrides(data: Any) -> WorktreeOverrides:
+    """Parse the optional ``worktree:`` block. Unknown keys warn, never fail."""
+    if not isinstance(data, dict):
+        if data is not None:
+            print(
+                f"Warning: .agentwire.yml `worktree:` should be a mapping "
+                f"with dir/base keys, got {type(data).__name__} — ignoring",
+                file=sys.stderr,
+            )
+        return WorktreeOverrides()
+    unknown = sorted(set(data) - _WORKTREE_OVERRIDE_KEYS)
+    if unknown:
+        print(
+            f"Warning: unknown key(s) in .agentwire.yml `worktree:` block: "
+            f"{', '.join(unknown)} (expected: dir, base)",
+            file=sys.stderr,
+        )
+    dir_val = data.get("dir")
+    base_val = data.get("base")
+    return WorktreeOverrides(
+        dir=Path(str(dir_val)).expanduser() if dir_val else None,
+        base=str(base_val) if base_val else None,
+    )
+
+
 @dataclass
 class ProjectConfig:
     """Project-level configuration for a project directory.
@@ -154,6 +196,7 @@ class ProjectConfig:
     parent: Optional[str] = None  # Parent session for hierarchical notifications
     shell: Optional[str] = None  # Default shell for task commands (default: /bin/sh)
     tasks: dict[str, Any] = field(default_factory=dict)  # Task definitions (raw dict, parsed by tasks.py)
+    worktree: WorktreeOverrides = field(default_factory=WorktreeOverrides)  # `agentwire worktree` overrides (#705)
 
     def to_dict(self) -> dict:
         """Convert to dictionary for YAML serialization."""
@@ -170,6 +213,13 @@ class ProjectConfig:
             d["shell"] = self.shell
         if self.tasks:
             d["tasks"] = self.tasks
+        if self.worktree.dir or self.worktree.base:
+            wt: dict[str, Any] = {}
+            if self.worktree.dir:
+                wt["dir"] = str(self.worktree.dir)
+            if self.worktree.base:
+                wt["base"] = self.worktree.base
+            d["worktree"] = wt
         return d
 
     @classmethod
@@ -189,6 +239,7 @@ class ProjectConfig:
             parent=parent,
             shell=shell,
             tasks=tasks if isinstance(tasks, dict) else {},
+            worktree=_parse_worktree_overrides(data.get("worktree")),
         )
 
 

{agentwire_dev-1.55.0 → agentwire_dev-1.56.0}/agentwire/roles/council-orchestrator.md

@@ -32,3 +32,11 @@ user's prompts out to them, collect their takes, and synthesize.
 - `council_status` shows roster health if something seems stuck.
 - Don't editorialize the lenses away. If Critic and Gut disagree, the
   disagreement *is* the product — surface it.
+
+## Closing the sitting
+
+When the user wraps up, stop with your synthesis so the minutes artifact
+carries it: `council_stop(synthesis="<your synthesis>")`. Stop renders the
+minutes (question + verbatim attributed takes + your synthesis) automatically
+whenever any prompt was asked. To (re)render the record at any other moment —
+including for a past sitting — use `council_minutes(synthesis=...)`.