induscode 0.1.1__tar.gz → 0.1.4__tar.gz

induscode-0.1.4/CHANGELOG.md

@@ -0,0 +1,167 @@
+# Changelog
+
+## 0.1.4 — 2026-06-28
+
+Interaction and reliability fixes for the live turn, the Ctrl+C / exit flow,
+and the picker boards. Requires `indusagi >= 0.1.3` (the background-free user
+turn). The version is single-sourced from `[project].version` via
+`importlib.metadata`, so `--version` and the banner pick it up after a
+reinstall.
+
+### Live turn
+
+- **Working spinner.** A new animated row — `⠴ Noodling… (5s · esc to
+  interrupt)` — shows while a turn is in flight: a braille spinner, a rotating
+  whimsical word (a concrete `Running tools` / `Compacting context` label
+  during those phases instead), an elapsed-seconds clock, and the interrupt
+  hint. It self-animates only while busy and hides itself when idle.
+- **Spinner spans the whole turn.** Busy state is no longer cleared on the
+  per-round `turn_end` the framework emits between tool rounds, so the spinner
+  stays up *through* tool calls until the final answer lands — it clears only
+  at true settlement (`idle` / fault / abort).
+
+### Pickers
+
+- **`/model` and `/settings` boards rebuilt to match the design.** Both are now
+  hand-rolled modal screens rather than thin restyles of the framework
+  dialogs: a teal round-bordered `⌕` search box, a saffron `›` cursor on the
+  selected row, per-row value tinting, a `↓ N more below` window hint, and a
+  description / choices detail line — matching the Saffron reference boards.
+
+### Ctrl+C, exit & abort
+
+- **Ctrl+C no longer hard-quits on the first press.** The first Ctrl+C now
+  shows `Press Ctrl+C again to exit.` and the confirm window widened to 2s. A
+  `SIGINT` handler routes Ctrl+C that arrives as a signal (some terminals
+  deliver it that way) through the same flow, so it no longer kills the app on
+  the first press.
+- **Silent abort.** Stopping a running turn with Ctrl+C / Esc no longer raises
+  a red `turn aborted by caller` error toast — the turn just stops quietly.
+- **Clean exit.** The conversation transcript is no longer dumped into the
+  terminal scrollback on an interactive exit; it is emitted only when a host
+  explicitly captures it.
+
+### Fixes
+
+- **`/clear` (and `/new`, `/reset`) crash.** These commands dispatched raw
+  `dict` events, which the live reducer rejected with `AttributeError: 'dict'
+  object has no attribute 'type'`; they now dispatch the proper event
+  dataclasses (`RowsSet` / `BlocksClear` / `StatusClear`, and `ToggleReasoning`
+  for `/debug`).
+
+## 0.1.3 — 2026-06-26
+
+Saffron interface refresh and live multi-agent visibility. The console gains
+a per-session welcome experience, a saffron theme as the default, denser
+in-chat tooling, and a pinned view onto background agents — including
+drill-in sub-agent progress streamed live from the task tool. No new
+subsystem packages; the version is single-sourced from this file's
+`[project].version` via `importlib.metadata`, so `--version` and the startup
+banner pick it up after a reinstall (the dev-checkout fallback is unchanged).
+
+### Theme & welcome
+
+- **Saffron theme is the new default** — the saffron scheme registers as the
+  startup console theme, replacing the prior default.
+- **Per-session saffron welcome card** — shown once per session, with a
+  rotating mascot, a rotating tip, and a *What's new* line summarising this
+  release.
+- **INDUS CODE chat masthead** — a saffron masthead is stamped above the
+  transcript after the first message of a session.
+
+### Pickers & menus
+
+- **Saffron `/settings` board** — the settings overlay re-skinned in the
+  saffron palette.
+- **Saffron `/model` board** — the model picker re-skinned to match.
+- **2-column saffron slash menu** — the slash-command autocomplete renders as
+  a two-column saffron menu.
+
+### Tool output & activity
+
+- **Concise tool output** — tool results collapse to a 3-line preview by
+  default, expandable to ~20 lines with **Ctrl+O**.
+- **Live Tool Activity panel disabled** — the streaming tool-activity panel is
+  turned off behind the `SHOW_TOOL_ACTIVITY` flag (default off).
+- **Workflow tool hidden** — the workflow tool is removed from the capability
+  deck behind the `WORKFLOW_TOOL_ENABLED` flag (default off).
+
+### Background agents
+
+- **Pinned Background Agents panel** — a saffron panel pinned in the console
+  listing active background agents.
+- **Subagent drill-in view** — press **←** on a background agent to open a
+  dedicated Subagent View.
+- **Live sub-agent progress** — sub-agent token counts and activity stream
+  live from the task tool into the panel and drill-in view.
+
+## 0.1.0 — 2026-06-11
+
+First release of the Python rebuild. Full port of the TypeScript
+`indusagi-coding-agent` (lineage **v0.1.62**, `indus-code-rebuild`) onto the
+Python `indusagi` framework, built milestone-by-milestone (M0–M6) per
+`indus-code-rebuild/PYTHON_PORT_PLAN/PLAN.md`. **649 tests green**, lineage
+scan clean, wheel verified in a fresh venv.
+
+### Subsystems
+
+- **workspace** — brand/version (single-sourced via `importlib.metadata`,
+  literal fallback) and the `~/.pindusagi` locator composed over the
+  framework `Locator` (`INDUSAGI_CODING_AGENT_DIR` > `INDUSAGI_HOME`).
+- **kit** — leaf utilities.
+- **settings** — two-tier `PreferenceStore` (project-write-only).
+- **briefing** — system-prompt composition, macro scanner, SKILL.md walker.
+- **window_budget** — context-window budgeting and condense seam
+  (3.6 chars/token heuristic kept).
+- **insight** — tracing wrapper over `indusagi.tracing` with collector sink,
+  replay, and FNV-1a gate.
+- **transcript_export** — SGR state machine, theme bridge, HTML publisher on
+  `markdown-it-py` + `pygments` (replacing `marked` + `highlight.js`).
+- **conductor** — turn loop with retry/queue-drain/persist-tail, condense
+  seam, fork/navigate, signal hub (10-tag translator table), model
+  catalog/matcher over `indusagi.ai`, branchable NDJSON `TranscriptStore`,
+  message⇄dict codec (`serialize.py`), skill parsing.
+- **runtime_bridge** — snapshot sink (mutable builder, per-push frozen
+  snapshots), broker (route/exchange/resume-tap), exchange driver + dialect
+  parsers.
+- **capability_deck** — builtin-bridge factory table, `PROFILE_TABLE`
+  provisioning, cards (todo ledger, bg-process daemon table on asyncio
+  subprocesses with SIGTERM→SIGKILL grace, task/saas/memory), bridge ledger
+  with ULID keys (`python-ulid`) and `mount_protocol_bridge` networking.
+- **addons** — discovery walk, importlib loader, event dispatcher
+  (gate-throw fails open, transform-throw keeps prior payload), host with
+  reserved names and first-wins conflicts.
+- **launch / boot / channels / sessions** — 17-flag invocation table on the
+  extended framework parser (`@file` attachments, `--`, list flags, `-pi`
+  clustering), credentials + OAuth adapter, multi-account `AuthVault` as the
+  single `auth.json` writer (0600, tolerant of framework single-record
+  shape), boot orchestrator + runners (oneshot/link/repl), NDJSON channel
+  framer (U+2028/29 escapes), session ops + link server + dialog bridge,
+  `SessionLibrary` over the transcript store.
+- **console / console_slash** — Textual TUI replacing the Ink console:
+  theme engine (4 schemes as native Textual themes), reducer, chrome
+  widgets, editor/keybindings with chord latch, autocomplete, overlays as
+  `push_screen` flows (incl. OAuth sign-in on `asyncio.Future`), and **26
+  slash commands** (18 transcript/workbench built-ins + 8 integration
+  commands, plus dynamic skill/template commands).
+- **entry** — console scripts `pindus` and `induscode`.
+
+### Key decisions
+
+- **Clean-room discipline** — independent implementation; no source copied
+  from any prior codebase; enforced by `scripts/lineage_scan.py` and the
+  public-API guard test, both release gates.
+- **Framework reuse over reinvention** — LLM abstraction, agent core, MCP
+  client, Textual shell primitives, and stage runner come from `indusagi`
+  (`[mcp,tui]` extras required); the agent keeps only its own seams
+  (transcript tree, vault, signal translation, deck).
+- **Behavioral parity with the TS lineage** — suites ported at full
+  strength (649 pytest cases vs the TS line's 332 vitest cases, never
+  weakened); versioning restarts at 0.1.0 while the TS line was at 0.1.62.
+- **Library swaps** — `marked`/`highlight.js` → `markdown-it-py`/`pygments`;
+  `ulid` → `python-ulid`; Ink/React → Textual; jiti virtual modules →
+  plain `importlib` addon loading.
+- **Packaging** — hatchling build; `py.typed` shipped; `NOTICE` and
+  `CREDITS.md` embedded via PEP 639 `license-files`; wheel gate = fresh
+  venv install (framework wheel first) + `--version`/`--help`/
+  `--list-models`/subsystem-import smokes.

{induscode-0.1.1 → induscode-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: induscode
-Version: 0.1.1
+Version: 0.1.4
 Summary: Indusagi coding agent — terminal-first AI coding agent on the indusagi framework (Python rebuild)
 Project-URL: Homepage, https://github.com/varunisrani/indusagi-ts
 Project-URL: Repository, https://github.com/varunisrani/indusagi-ts
@@ -22,7 +22,7 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
-Requires-Dist: indusagi[mcp,tui]>=0.1.1
+Requires-Dist: indusagi[mcp,tui]>=0.1.3
 Requires-Dist: markdown-it-py>=3.0
 Requires-Dist: pygments>=2.18
 Requires-Dist: python-ulid>=2.7

{induscode-0.1.1 → induscode-0.1.4}/pyproject.toml

@@ -8,7 +8,7 @@ name = "induscode"
 # it ports the TypeScript lineage `indusagi-coding-agent`, which was at VERSION
 # 0.1.62 (indus-code-rebuild/src/workspace/brand.ts) when this port began.
 # Runtime code reads this via importlib.metadata — never duplicate it.
-version = "0.1.1"
+version = "0.1.4"
 description = "Indusagi coding agent — terminal-first AI coding agent on the indusagi framework (Python rebuild)"
 authors = [{ name = "Varun Israni" }, { name = "IndusAGI Team", email = "team@indusagi.ai" }]
 readme = "README.md"
@@ -32,10 +32,11 @@ dependencies = [
   # The framework, from PyPI. The [mcp,tui] extras are required: the framework's
   # shell_app barrel (which our workspace layer composes) imports `mcp` and
   # `textual` eagerly, and the agent's own MCP enrollment + Textual console need
-  # them anyway. Pinned to the published framework (>=0.1.1).
+  # them anyway. Pinned to the published framework (>=0.1.3 — the
+  # background-free user turn lands in the framework's react_ink).
   # For local dev, editable-install the framework first:
   #   pip install -e ../indusagi-python-rebuild  (then pip install -e .)
-  "indusagi[mcp,tui]>=0.1.1",
+  "indusagi[mcp,tui]>=0.1.3",
   "markdown-it-py>=3.0", # transcript-export markdown (replaces marked)
   "pygments>=2.18",      # transcript-export highlighting (replaces highlight.js)
   "python-ulid>=2.7",    # bridge-ledger ULID keys (capability_deck)

induscode-0.1.4/src/induscode/boot/runners/delegate_runner.py

@@ -0,0 +1,376 @@
+"""Boot helper: a live :class:`DelegateRunner` that makes the ``task`` tool real.
+
+Port of TS ``src/boot/runners/delegate-runner.ts``.
+
+The ``task`` capability (:mod:`induscode.capability_deck.cards.task`) advertises
+sub-agent delegation but only *runs* it when a :class:`DelegateRunner` is wired
+into the deck context under :data:`DELEGATE_HANDLE_KEY`; absent one it degrades
+to a typed stub. This module supplies that runner.
+
+Each delegated objective spins a *fresh, isolated* framework :class:`~indusagi.agent.Agent`
+(the same ``Agent`` the conductor already drives) bound to the parent's model id
+and credential resolver, given a survey-style system prompt and a deck that
+DELIBERATELY excludes the ``task`` card. That exclusion is the recursion guard:
+a sub-agent with no ``task`` tool cannot spawn its own sub-agents. The runner
+submits one prompt, lets the sub-agent run its own tool loop to completion, then
+extracts the final assistant turn's text as the single report handed back to the
+parent.
+
+The runner never raises out of :meth:`run`: a model that does not resolve, a
+sub-agent error, or an empty transcript all map to a ``DelegateResult(ok=False,
+report=...)`` so a delegation failure surfaces to the parent agent as an
+ordinary tool error rather than crashing the turn.
+
+The ``spawn`` / ``tools`` options are pure test seams — they let a unit test
+drive the runner with an in-memory fake instead of a real network round-trip.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable, Sequence
+from typing import Any, Protocol
+
+from induscode.capability_deck import AgentTool, DeckContext, provision_deck
+from induscode.conductor import ModelCatalog, ModelMatcher
+
+from ...capability_deck.cards.task import (
+    ActivityLine,
+    DelegateProgress,
+    DelegateRequest,
+    DelegateResult,
+    DelegateRunner,
+)
+
+__all__ = [
+    "DelegateRunnerOptions",
+    "DelegateSubAgent",
+    "create_delegate_runner",
+]
+
+
+# ---------------------------------------------------------------------------
+# The minimal sub-agent surface the runner drives
+# ---------------------------------------------------------------------------
+
+
+class DelegateSubAgent(Protocol):
+    """The minimal sub-agent surface the runner drives.
+
+    A real framework :class:`~indusagi.agent.Agent` satisfies this
+    structurally; a test passes a lightweight fake via
+    :attr:`DelegateRunnerOptions.spawn`. Only the pieces the runner touches are
+    named — submit a prompt, abort, and read the resulting transcript/error
+    afterward.
+    """
+
+    async def prompt(self, input: str) -> None: ...
+
+    def abort(self) -> None: ...
+
+    @property
+    def state(self) -> Any:
+        """The agent state: ``.messages`` (a sequence) and an optional
+        ``.error`` string."""
+        ...
+
+    # Optional event subscription (the real framework Agent provides it). The
+    # runner uses it to recompute live token spend as the sub-agent works; a
+    # test fake may omit it, in which case no progress is reported. (A Python
+    # Protocol cannot mark a method optional, so the runner probes with
+    # ``getattr`` instead of declaring it here.)
+
+
+# ---------------------------------------------------------------------------
+# Transcript projection helpers
+# ---------------------------------------------------------------------------
+
+
+def _field(obj: Any, name: str, default: Any = None) -> Any:
+    """Read ``name`` off a mapping key or an attribute, whichever the value
+    carries (framework messages are dataclasses; tests may pass dicts)."""
+    if isinstance(obj, dict):
+        return obj.get(name, default)
+    return getattr(obj, name, default)
+
+
+def _sum_tokens(messages: Sequence[Any]) -> int:
+    """Sum the token spend across a sub-agent's assistant turns.
+
+    Each assistant message carries a ``usage`` of input/output token counts;
+    this totals input + output across the transcript so far, tolerating
+    messages that carry no usage (user/tool turns, or a turn still streaming).
+    """
+    total = 0
+    for message in messages:
+        usage = _field(message, "usage")
+        if usage is not None:
+            total += int(_field(usage, "input", 0) or 0)
+            total += int(_field(usage, "output", 0) or 0)
+    return total
+
+
+def _one_line(text: str, max_len: int = 120) -> str:
+    """Collapse text to a single trimmed line clipped to ``max_len`` chars."""
+    flat = " ".join(text.split()).strip()
+    if len(flat) > max_len:
+        return f"{flat[: max_len - 1]}…"
+    return flat
+
+
+def _arg_preview(args: Any) -> str:
+    """A compact ``(arg)`` preview from a tool call's first argument value."""
+    if not isinstance(args, dict) or len(args) == 0:
+        return ""
+    value = next(iter(args.values()))
+    if isinstance(value, str):
+        text = value
+    else:
+        import json
+
+        try:
+            text = json.dumps(value)
+        except Exception:
+            text = str(value)
+    return f" ({_one_line(str(text), 56)})"
+
+
+def _build_activity(messages: Sequence[Any]) -> tuple[ActivityLine, ...]:
+    """Project a sub-agent's recent activity into compact display lines.
+
+    Splits assistant messages into reasoning/answer snippets and tool calls,
+    newest last, capped at the last ~14 so the stream stays light to ship over
+    the progress channel.
+    """
+    out: list[ActivityLine] = []
+    for message in messages:
+        if _field(message, "role") != "assistant":
+            continue
+        content = _field(message, "content")
+        if not isinstance(content, (list, tuple)):
+            continue
+        for part in content:
+            part_type = _field(part, "type")
+            if part_type == "text":
+                text = _field(part, "text")
+                if isinstance(text, str) and text.strip():
+                    out.append(ActivityLine(tone="reason", text=_one_line(text)))
+            elif part_type == "thinking":
+                thinking = _field(part, "thinking")
+                if isinstance(thinking, str) and thinking.strip():
+                    out.append(ActivityLine(tone="reason", text=_one_line(thinking)))
+            elif part_type == "toolCall":
+                name = _field(part, "name")
+                if isinstance(name, str):
+                    label = name[:1].upper() + name[1:]
+                    out.append(
+                        ActivityLine(
+                            tone="tool",
+                            text=f"{label}{_arg_preview(_field(part, 'arguments'))}",
+                        )
+                    )
+    return tuple(out[-14:])
+
+
+def _final_assistant_text(messages: Sequence[Any]) -> str:
+    """Extract the report text from a finished sub-agent transcript.
+
+    Walks backward to the last ``assistant`` message and joins its
+    ``type=='text'`` blocks; thinking and tool-call blocks carry no report and
+    are skipped. Returns ``''`` when there is no assistant turn (or it produced
+    no text), which the caller maps to a ``'(no output)'`` report.
+    """
+    for message in reversed(list(messages)):
+        if _field(message, "role") != "assistant":
+            continue
+        content = _field(message, "content")
+        if not isinstance(content, (list, tuple)):
+            return content if isinstance(content, str) else ""
+        parts: list[str] = []
+        for block in content:
+            if _field(block, "type") == "text":
+                text = _field(block, "text")
+                if isinstance(text, str):
+                    parts.append(text)
+        return "".join(parts)
+    return ""
+
+
+# ---------------------------------------------------------------------------
+# Options
+# ---------------------------------------------------------------------------
+
+
+class DelegateRunnerOptions:
+    """Configuration for :func:`create_delegate_runner`.
+
+    A plain options bag (the TS interface). ``spawn`` and ``tools`` are pure
+    test seams.
+    """
+
+    def __init__(
+        self,
+        *,
+        modelId: str,
+        cwd: str,
+        system: str,
+        getApiKey: Callable[[str], Awaitable[str | None] | str | None] | None = None,
+        spawn: Callable[[str, str | None], DelegateSubAgent] | None = None,
+        tools: Callable[[], list[AgentTool]] | None = None,
+    ) -> None:
+        #: The model id the sub-agent runs under (the parent's resolved model).
+        self.modelId = modelId
+        #: The working directory the sub-agent's deck is scoped to.
+        self.cwd = cwd
+        #: The system prompt that shapes the sub-agent's behaviour.
+        self.system = system
+        #: Per-call credential resolver, forwarded to the framework Agent.
+        self.getApiKey = getApiKey
+        #: Test seam: build the sub-agent from the objective.
+        self.spawn = spawn
+        #: Test seam: the tool deck the sub-agent runs with.
+        self.tools = tools
+
+
+# ---------------------------------------------------------------------------
+# Runner factory
+# ---------------------------------------------------------------------------
+
+
+class _LiveDelegateRunner:
+    """A live :class:`DelegateRunner` bound to a resolved model + options."""
+
+    def __init__(self, options: DelegateRunnerOptions, model: Any) -> None:
+        self._options = options
+        # Resolved once up front; ``None`` means every run reports ok=False
+        # rather than raising (a misconfigured model can never crash a turn).
+        self._model = model
+
+    def _spawn_agent(self, request: DelegateRequest) -> DelegateSubAgent:
+        from indusagi.agent import Agent
+
+        opts = self._options
+        if opts.tools is not None:
+            tools = opts.tools()
+        else:
+            # The sub-agent's deck — the 'authoring' profile excludes the
+            # ``task`` card, so the sub-agent cannot recurse into delegation.
+            tools = provision_deck("authoring", DeckContext(cwd=opts.cwd)).tools()
+        initial_state: dict[str, Any] = {
+            # ``model`` is guaranteed non-None here: the run() guard returns
+            # early when no spawn seam was given and the model did not resolve.
+            "model": self._model,
+            "systemPrompt": opts.system,
+            "tools": list(tools),
+        }
+        kwargs: dict[str, Any] = {}
+        if opts.getApiKey is not None:
+            kwargs["get_api_key"] = opts.getApiKey
+        return Agent(initial_state=initial_state, **kwargs)  # type: ignore[return-value]
+
+    async def run(
+        self,
+        request: DelegateRequest,
+        signal: object | None = None,
+        on_progress: Callable[[DelegateProgress], None] | None = None,
+    ) -> DelegateResult:
+        opts = self._options
+        if opts.spawn is None and self._model is None:
+            return DelegateResult(ok=False, report="no model resolved for delegation")
+        if signal is not None and bool(getattr(signal, "aborted", False)):
+            return DelegateResult(ok=False, report="delegation aborted")
+
+        # Fold any parent-supplied context into the objective so the otherwise
+        # history-less sub-agent starts with everything it needs.
+        objective = (
+            f"{request.objective}\n\nContext:\n{request.context}"
+            if request.context
+            else request.objective
+        )
+
+        agent: DelegateSubAgent = (
+            opts.spawn(request.objective, request.context)
+            if opts.spawn is not None
+            else self._spawn_agent(request)
+        )
+
+        # Forward cancellation: an abort raised mid-run calls agent.abort().
+        on_abort = agent.abort
+        add_listener = getattr(signal, "add_event_listener", None) or getattr(
+            signal, "addEventListener", None
+        )
+        if add_listener is not None:
+            try:
+                add_listener("abort", on_abort)
+            except Exception:
+                add_listener = None
+
+        # Stream live token spend while the sub-agent works: recompute the
+        # running total on every agent event and report it (only when it
+        # changes) so the host's background-agents panel shows a live count. The
+        # framework Agent provides ``subscribe``; a fake without it reports
+        # nothing.
+        last_signature = ""
+
+        def report_progress() -> None:
+            nonlocal last_signature
+            if on_progress is None:
+                return
+            messages = _field(agent.state, "messages") or ()
+            tokens = _sum_tokens(messages)
+            activity = _build_activity(messages)
+            signature = f"{tokens}:{len(activity)}"
+            if signature != last_signature:
+                last_signature = signature
+                on_progress(DelegateProgress(tokens=tokens, activity=activity))
+
+        off_progress: Callable[[], None] | None = None
+        subscribe = getattr(agent, "subscribe", None)
+        if on_progress is not None and callable(subscribe):
+            off_progress = subscribe(lambda _event: report_progress())
+
+        try:
+            await agent.prompt(objective)
+            report_progress()
+        except Exception as cause:  # noqa: BLE001 — a sub-agent failure is a
+            # delegation failure, not a crash of the parent's tool call.
+            message = str(cause)
+            return DelegateResult(ok=False, report=message or "delegation failed")
+        finally:
+            if off_progress is not None:
+                try:
+                    off_progress()
+                except Exception:
+                    pass
+            remove_listener = getattr(signal, "remove_event_listener", None) or getattr(
+                signal, "removeEventListener", None
+            )
+            if add_listener is not None and remove_listener is not None:
+                try:
+                    remove_listener("abort", on_abort)
+                except Exception:
+                    pass
+
+        error = _field(agent.state, "error")
+        report = _final_assistant_text(_field(agent.state, "messages") or ())
+        return DelegateResult(
+            ok=error is None and len(report) > 0,
+            report=error if error is not None else (report or "(no output)"),
+        )
+
+
+def create_delegate_runner(opts: DelegateRunnerOptions) -> DelegateRunner:
+    """Build a live :class:`DelegateRunner` the host wires into the deck context.
+
+    The model is resolved once up front; if the id resolves to nothing the
+    runner still builds but every :meth:`run` reports ``ok=False`` rather than
+    raising, so a misconfigured model can never crash the parent's turn.
+
+    :param opts: the model id, cwd, system prompt, and optional credential/test
+        seams
+    :returns: a runner satisfying the task card's :class:`DelegateRunner`
+        contract
+    """
+    # Resolve the framework Model once (same pattern the conductor uses).
+    card = ModelMatcher(ModelCatalog()).resolve_card(opts.modelId)
+    model = card.model if card is not None else None
+    return _LiveDelegateRunner(opts, model)