delegate-agent-cli 0.27.0__tar.gz → 0.28.0__tar.gz

{delegate_agent_cli-0.27.0 → delegate_agent_cli-0.28.0}/CHANGELOG.md

@@ -5,7 +5,36 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.28.0] - 2026-08-05
+
+### Added
+
+- Added `delegate runs --structural` and `delegate ps --structural` for
+  content-free local status collection, including lifecycle, model, group,
+  status, timestamp, and root initiator provenance.
+- Tracked runs now retain a validated root initiator across nested Delegate
+  launches and persistent-worktree execution.
+
+### Changed
+
+- Codex quota fallback is now explicitly configured with
+  `codex.fallbackProfile`, supports arbitrary profile definitions, and keeps
+  temporary blocks by resolved credential identity rather than profile alias.
+  Default work/personal credential homes continue to interoperate with legacy
+  profile launchers without allowing remapped aliases to share state.
+- Codex-only failover no longer depends on private Claude shim names or hidden
+  runtime controls. Retry and persistent-worktree paths retain the account
+  that is actually serving the run.
+
+### Fixed
+
+- Structural run listings now exclude raw terminal/provider events and apply
+  normal secret redaction to retained fields.
+- Fallback failures persist the correct account block and provider-reported
+  reset time; a blocked fallback is skipped, and retries no longer return to a
+  blocked primary after a preflight swap.
+- Failover tests isolate their state from the user's home directory, and
+  `delegate ps --help` now advertises its supported structural view.
 
 ## [0.27.0] - 2026-08-01
 
@@ -888,6 +917,7 @@ Usage-audit fix wave: 82 sessions and 1,241 delegate invocations from one week o
 
 - Releases before 0.1.3 predate this changelog.
 
+[0.28.0]: https://github.com/treygoff24/delegate-agent/compare/v0.27.0...v0.28.0
 [0.27.0]: https://github.com/treygoff24/delegate-agent/compare/v0.26.0...v0.27.0
 [0.26.0]: https://github.com/treygoff24/delegate-agent/compare/v0.25.0...v0.26.0
 [0.25.0]: https://github.com/treygoff24/delegate-agent/compare/v0.24.0...v0.25.0

{delegate_agent_cli-0.27.0 → delegate_agent_cli-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: delegate-agent-cli
-Version: 0.27.0
+Version: 0.28.0
 Summary: A tiny CLI for delegating bounded agent tasks across coding-agent runtimes.
 Author: Trey Goff
 License-Expression: MIT
@@ -167,6 +167,8 @@ delegate --json capabilities refresh   # refresh the active profile's discovery
 
 Discover commands as you go: `delegate <command> --help` prints focused help for any command path, and `delegate --json <command> --help` returns an agent-friendly spec of its usage, arguments, and options. For launch and `dry-run` commands, `--json` and `--isolation` may also appear before inline prompt text begins, for example `delegate codex work --prompt-file task.md --json`. `delegate --json describe` includes a `commands` catalog of the whole surface. Cached `models` and `capabilities` reads launch no child process. `models <engine> --live` performs a one-off probe without updating the cache; rerun `delegate setup` or `delegate capabilities refresh` when ordinary launches should consume newly discovered models or effort levels.
 
+Codex tracked runs can opt into a one-run quota fallback with `codex.fallbackProfile`; hashed credential namespace is canonical, while default work/personal credential homes also mirror compatible legacy alias keys so existing launchers share blocks. Remapped aliases remain isolated. See [Configuration](docs/configuration.md).
+
 From this development checkout, use `python3 bin/delegate.py ...` instead of an installed `delegate` shim.
 
 ### WSL setup notes

{delegate_agent_cli-0.27.0 → delegate_agent_cli-0.28.0}/README.md

@@ -134,6 +134,8 @@ delegate --json capabilities refresh   # refresh the active profile's discovery
 
 Discover commands as you go: `delegate <command> --help` prints focused help for any command path, and `delegate --json <command> --help` returns an agent-friendly spec of its usage, arguments, and options. For launch and `dry-run` commands, `--json` and `--isolation` may also appear before inline prompt text begins, for example `delegate codex work --prompt-file task.md --json`. `delegate --json describe` includes a `commands` catalog of the whole surface. Cached `models` and `capabilities` reads launch no child process. `models <engine> --live` performs a one-off probe without updating the cache; rerun `delegate setup` or `delegate capabilities refresh` when ordinary launches should consume newly discovered models or effort levels.
 
+Codex tracked runs can opt into a one-run quota fallback with `codex.fallbackProfile`; hashed credential namespace is canonical, while default work/personal credential homes also mirror compatible legacy alias keys so existing launchers share blocks. Remapped aliases remain isolated. See [Configuration](docs/configuration.md).
+
 From this development checkout, use `python3 bin/delegate.py ...` instead of an installed `delegate` shim.
 
 ### WSL setup notes

{delegate_agent_cli-0.27.0 → delegate_agent_cli-0.28.0}/docs/agent-setup.md

@@ -7,7 +7,7 @@ This guide covers both human setup and non-interactive setup for agents or CI jo
 1. Install Delegate from the source repository:
 
    ```bash
-   python3 -m pip install "delegate-agent @ git+https://github.com/treygoff24/delegate-agent.git"
+   python3 -m pip install "delegate-agent-cli @ git+https://github.com/treygoff24/delegate-agent.git"
    ```
 
    For a development checkout, prefer:

{delegate_agent_cli-0.27.0 → delegate_agent_cli-0.28.0}/docs/cli-reference.md

@@ -1008,7 +1008,7 @@ repo copy or persistent worktree itself.
 Tracked runs return bounded parent-facing output and store local metadata under `.delegate/` in the source workspace.
 
 ```bash
-delegate runs [--active|--running|--stale|--recent] [--harness HARNESS] [--group NAME] [--limit N]
+delegate runs [--active|--running|--stale|--recent] [--harness HARNESS] [--group NAME] [--limit N] [--structural]
 delegate runs prune [--older-than DAYS] [--dry-run]
 delegate ps [--harness HARNESS] [--group NAME] [--limit N]
 delegate snapshot [--latest HARNESS] [--no-redact] <handle>
@@ -1055,8 +1055,10 @@ creating a Run or writing a prompt record.
 | Include dirty | `includeDirty` | `--include-dirty` | Source and explicit values are creation-only and are dropped for ordinary resume with a note. | Retained only as a drop decision; on a persistent/attached source, explicit `--include-dirty` is rejected because attachment does not create or sync a worktree. |
 
 `delegate runs` defaults to recent runs. `--active` preserves the legacy active view and includes both live `running` runs and `stale` runs. Use `--running` for only live tracked processes and `--stale` for runs recorded as running whose PID is missing or dead. `--active`, `--running`, `--stale`, and `--recent` are mutually exclusive. `--group NAME` filters by launch group and the runs table shows a `group` column when any visible run has one.
+`--structural` omits content-bearing run fields and emits only identity, lifecycle, model,
+timestamp, group/mode, and `initiatorRoot` metadata. It is intended for local status collectors.
 `delegate ps` is the shorter first-class form of `delegate runs --active` and
-accepts the same harness, group, and limit selectors.
+accepts the same harness, group, limit, and structural selectors.
 
 `delegate runs prune` removes old terminal Run records from the workspace Registry so they stop accumulating forever. Only runs whose effective status is terminal (`succeeded`, `failed`, `cancelled`, or `stale` from a dead child) and whose last Registry activity is older than the threshold (default 30 days; override with `--older-than DAYS`) are eligible. Effectively running runs are always skipped, and persistent-worktree runs are skipped unless their worktree is recorded as removed or missing — pruning the record of a live worktree would orphan it from `worktree list`/`show`/`remove`. Pruning deletes the per-Run directory (Snapshot, Manifest, logs, events, Completion Report) and the retained raw-log archive; worktree paths on disk are never touched. `--dry-run` reports what would be removed without changing anything. JSON output uses schema `delegate.runs-prune.v1` with `planned`, `removed`, `skipped` (each entry carries a `reason`), and `errors` sections.
 
@@ -1114,7 +1116,12 @@ Persistent worktree completions also include `branch`, `worktree`, a
 state, changed file count, diff stat, and commits created by the child. When a
 Codex usage-limit fallback fires, the completion payload also includes
 `codexAuthFallback` metadata (reason, the primary and fallback profile names,
-both exit codes, and a redacted primary stderr tail).
+both exit codes, and a redacted primary stderr tail). The fallback is Codex-only
+and is enabled only by `codex.fallbackProfile`; Delegate remembers temporary
+blocks by hashed credential namespace (`CODEX_HOME/auth.json` plus
+`codex.profile`) as canonical state. Default work/personal credential homes
+also mirror compatible legacy alias keys so existing launchers share blocks;
+remapped aliases remain isolated.
 
 Snapshot JSON uses schema `delegate.snapshot.v1` and includes fields such as `alias`, `runId`, `harness`, `status`, `rawStatus`, `effectiveStatus`, `staleReason`, `nextActions`, `cwd`, `executionCwd`, `workspaceRoot`, `assistantText`, `recentEvents`, `warnings`, `exitCode`, reasoning metadata, terminal metadata, and isolation/worktree metadata when applicable. `workspaceRoot` is also exported to the child as `WORKSPACE_ROOT`, so commands can anchor workspace-relative paths after changing directories. Inspection commands do not rewrite a stale run's recorded state; they expose the raw recorded status plus the effective status computed from the current PID check. Run-output and worktree show output include `requestedHandle`, `resolvedHandle`, and `resolutionKind` (`literal`, `latest`, or `latest_model`) when a handle resolves indirectly. For bare harness handles, snapshot, run-output, and wait also report `resolvedRunId`, `resolvedAlias`, `resolvedWorkspace`, `resolvedAge`, and `resolvedAgeSeconds`. Resolutions older than 24 hours add a `bare_handle_stale` warning suggesting `--cwd` or an explicit handle.
 

{delegate_agent_cli-0.27.0 → delegate_agent_cli-0.28.0}/docs/configuration.md

@@ -336,7 +336,7 @@ Controls local run recording.
 - `models`: optional map of local aliases to Codex model IDs for `--model` / JSON `model`. Alias keys must not collide with mode names, equal the engine's own name, or start with `-`.
 - `defaultReasoningEffort`: optional non-empty effort string. When a Codex model resolves (run input or `codex.defaultModel`) and supports the level, Delegate emits a Codex config override; otherwise the run proceeds without reasoning effort and records a warning. An explicit `--reasoning-effort` flag fails closed for unsupported levels, but can target the Codex harness default model when no model is configured.
 - `profile`: optional Codex CLI config overlay name. It is config-only; JSON run input cannot set it.
-- `fallbackProfile`: optional top-level `profiles.definitions` name for one quota-limit retry on tracked Codex runs. The fallback profile must define `env.CODEX_HOME`.
+- `fallbackProfile`: optional top-level `profiles.definitions` name for Codex-only quota fallback. The fallback profile must define `env.CODEX_HOME`. Tracked Codex runs persist temporary usage-limit blocks under `~/.ai-profiles/runtime/failover/`; hashed credential namespace (`CODEX_HOME/auth.json` plus `codex.profile`) is canonical, while default work/personal credential homes also mirror compatible legacy alias keys so existing launchers share blocks. Remapped aliases remain isolated. If both the primary and fallback credential namespaces are blocked, Delegate keeps the primary attempt and does not launch the known-blocked fallback.
 - `workSandbox`: `read-only`, `workspace-write`, or `danger-full-access` for Codex work mode when full bypass is not enabled.
 - `ephemeral`: include Codex `--ephemeral` in JSON-streaming runs.
 - `ignoreUserConfig`: include Codex `--ignore-user-config`.

{delegate_agent_cli-0.27.0 → delegate_agent_cli-0.28.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "delegate-agent-cli"
-version = "0.27.0"
+version = "0.28.0"
 description = "A tiny CLI for delegating bounded agent tasks across coding-agent runtimes."
 readme = "README.md"
 requires-python = ">=3.11"

{delegate_agent_cli-0.27.0 → delegate_agent_cli-0.28.0}/src/delegate_agent/__init__.py

@@ -1,5 +1,5 @@
 """Delegate Agent CLI package."""
 
-VERSION = "0.27.0"
+VERSION = "0.28.0"
 
 __all__ = ["VERSION"]

{delegate_agent_cli-0.27.0 → delegate_agent_cli-0.28.0}/src/delegate_agent/cli.py

@@ -635,6 +635,8 @@ def make_run_context(
         ),
         auth_profile=request.auth_profile,
         fallback_auth_profile=request.fallback_auth_profile,
+        codex_failover_identity=request.codex_failover_identity,
+        codex_fallback_failover_identity=request.codex_fallback_failover_identity,
         include_dirty=request.include_dirty,
         mail_push=request.mail_push,
         group=request.group,
@@ -675,6 +677,12 @@ def _set_child_root_env(request: Request, source_workspace: ResolvedWorkspace) -
     request.env_overrides = env
 
 
+def _apply_initiator_root(request: Request) -> str | None:
+    initiator_root, env = run_metadata.apply_initiator_root_env(request.env_overrides)
+    request.env_overrides = env
+    return initiator_root
+
+
 def _artifact_files(root: Path) -> list[str]:
     return sorted(str(item) for item in root.rglob("*") if item.is_file() or item.is_symlink())
 
@@ -786,22 +794,26 @@ def _execute_attached_worktree(
     if request.mode == MODE_WORK and delegate_config.mail_enabled(config):
         mail.prepare_mail_storage(registry_root)
     mail.sanitize_inherited_mail_identity(request.env_overrides)
+    metadata = {
+        "mode": request.mode,
+        "model": request.model,
+        "modelAlias": request.model_alias,
+        "modelResolved": request.model,
+        "group": request.group,
+        "workflowAgentKey": request.workflow_agent_key,
+        "cwd": source_workspace.path,
+        "worktreeAttachment": {
+            **(iso.attachment or {}),
+            "startHeadOid": start_head_oid,
+        },
+    }
+    run_metadata.add_initiator_metadata(
+        metadata, run_metadata.resolve_initiator_root(request.env_overrides or {})
+    )
     run_id, alias = run_registry.register_run(
         registry_root,
         harness=request.engine,
-        metadata={
-            "mode": request.mode,
-            "model": request.model,
-            "modelAlias": request.model_alias,
-            "modelResolved": request.model,
-            "group": request.group,
-            "workflowAgentKey": request.workflow_agent_key,
-            "cwd": source_workspace.path,
-            "worktreeAttachment": {
-                **(iso.attachment or {}),
-                "startHeadOid": start_head_oid,
-            },
-        },
+        metadata=metadata,
     )
     child_env = request.env_overrides or {}
     if request.mode == MODE_WORK:
@@ -986,6 +998,7 @@ def execute_request(
     stderr: TextIO,
 ) -> tuple[int, JsonObject | None]:
     _set_child_root_env(request, source_workspace)
+    initiator_root = _apply_initiator_root(request)
     profiles.strip_mail_identity(request.env_overrides)
     if request.mode == MODE_CALL:
         call_response: tuple[int, JsonObject | None] | None = None
@@ -1013,18 +1026,20 @@ def execute_request(
                     workspace_kind=source_workspace.kind,
                 )
                 maybe_run_retention_pass(registry_root, config)
+                metadata = {
+                    "mode": request.mode,
+                    "model": request.model,
+                    "modelAlias": request.model_alias,
+                    "modelResolved": request.model,
+                    "group": request.group,
+                    "workflowAgentKey": request.workflow_agent_key,
+                    "cwd": source_workspace.path,
+                }
+                run_metadata.add_initiator_metadata(metadata, initiator_root)
                 run_id, alias = run_registry.register_run(
                     registry_root,
                     harness=request.engine,
-                    metadata={
-                        "mode": request.mode,
-                        "model": request.model,
-                        "modelAlias": request.model_alias,
-                        "modelResolved": request.model,
-                        "group": request.group,
-                        "workflowAgentKey": request.workflow_agent_key,
-                        "cwd": source_workspace.path,
-                    },
+                    metadata=metadata,
                 )
                 artifact_id = run_id
                 ctx_runner = make_run_context(
@@ -1282,22 +1297,24 @@ def execute_request(
         if isolated_request.mode == MODE_WORK and delegate_config.mail_enabled(config):
             mail.prepare_mail_storage(registry_root)
         mail.sanitize_inherited_mail_identity(isolated_request.env_overrides)
+        metadata = {
+            "mode": isolated_request.mode,
+            "model": isolated_request.model,
+            "modelAlias": isolated_request.model_alias,
+            "modelResolved": isolated_request.model,
+            "group": isolated_request.group,
+            "workflowAgentKey": isolated_request.workflow_agent_key,
+            "cwd": (
+                isolated_request.isolation_context.source_workspace
+                if isolated_request.isolation_context is not None
+                else source_workspace.path
+            ),
+        }
+        run_metadata.add_initiator_metadata(metadata, initiator_root)
         run_id, alias = run_registry.register_run(
             registry_root,
             harness=isolated_request.engine,
-            metadata={
-                "mode": isolated_request.mode,
-                "model": isolated_request.model,
-                "modelAlias": isolated_request.model_alias,
-                "modelResolved": isolated_request.model,
-                "group": isolated_request.group,
-                "workflowAgentKey": isolated_request.workflow_agent_key,
-                "cwd": (
-                    isolated_request.isolation_context.source_workspace
-                    if isolated_request.isolation_context is not None
-                    else source_workspace.path
-                ),
-            },
+            metadata=metadata,
         )
         child_env = isolated_request.env_overrides or {}
         if isolated_request.mode == MODE_WORK:

{delegate_agent_cli-0.27.0 → delegate_agent_cli-0.28.0}/src/delegate_agent/cli_parser.py

@@ -1875,6 +1875,7 @@ def parse_runs(
     recent = False
     running = False
     stale = False
+    structural = False
     harness: str | None = None
     group: str | None = None
     limit: int | None = None
@@ -1897,6 +1898,10 @@ def parse_runs(
             recent = True
             i += 1
             continue
+        if token == "--structural":
+            structural = True
+            i += 1
+            continue
         if token == "--harness":
             if i + 1 >= len(rest):
                 raise DelegateError(
@@ -1953,6 +1958,7 @@ def parse_runs(
             harness=harness,
             group=group,
             limit=limit,
+            structural=structural,
             json_mode=json_mode,
         ),
     )

{delegate_agent_cli-0.27.0 → delegate_agent_cli-0.28.0}/src/delegate_agent/command_help.py

@@ -875,7 +875,7 @@ COMMAND_SPECS: dict[str, CommandSpec] = {
         summary="List tracked runs, optionally filtered by activity, recency, or harness.",
         usage=(
             "delegate [--json] runs [--active|--running|--stale|--recent] "
-            "[--harness HARNESS] [--group NAME] [--limit N]",
+            "[--harness HARNESS] [--group NAME] [--limit N] [--structural]",
         ),
         options=(
             OptionSpec(
@@ -893,6 +893,11 @@ COMMAND_SPECS: dict[str, CommandSpec] = {
             ),
             OptionSpec("--limit", "N", "Cap the number of runs listed (positive integer)."),
             OptionSpec("--group", "NAME", "Filter by launch group."),
+            OptionSpec(
+                "--structural",
+                None,
+                "Emit only lifecycle, model, provenance, and identity metadata; omit run content.",
+            ),
         ),
         examples=(
             "delegate runs --active",
@@ -900,6 +905,7 @@ COMMAND_SPECS: dict[str, CommandSpec] = {
             "delegate runs --stale",
             "delegate runs --harness cursor --limit 5",
             "delegate runs --group wave4",
+            "delegate --json runs --recent --structural",
         ),
         notes=("--active, --running, --stale, and --recent are mutually exclusive.",),
         see_also=("ps", "runs prune", "snapshot", "run-output"),
@@ -1101,13 +1107,20 @@ COMMAND_SPECS: dict[str, CommandSpec] = {
     "ps": CommandSpec(
         name="ps",
         summary="List active tracked runs (alias for runs --active).",
-        usage=("delegate [--json] ps [--harness HARNESS] [--group NAME] [--limit N]",),
+        usage=(
+            "delegate [--json] ps [--harness HARNESS] [--group NAME] [--limit N] [--structural]",
+        ),
         options=(
             OptionSpec("--harness", "HARNESS", f"Filter by harness: {ENGINES_PROSE}."),
             OptionSpec("--limit", "N", "Cap the number of runs listed (positive integer)."),
             OptionSpec("--group", "NAME", "Filter by launch group."),
+            OptionSpec(
+                "--structural",
+                None,
+                "Emit only lifecycle, model, provenance, and identity metadata; omit run content.",
+            ),
         ),
-        examples=("delegate ps", "delegate ps --harness codex"),
+        examples=("delegate ps", "delegate ps --harness codex", "delegate --json ps --structural"),
         notes=("Equivalent to delegate runs --active.",),
         see_also=("runs", "snapshot", "run-output"),
         unsupported_global_options=("--auth-profile",),
@@ -2101,7 +2114,7 @@ def render_overview_text() -> str:
         "[--active|--running|--stale|--recent] [--harness HARNESS] [--limit N]",
         "delegate [--cwd PATH] [--json] runs prune [--older-than DAYS] [--dry-run]",
         "delegate [--cwd PATH] [--json] mail {send,inbox,read,status,watch,prune} ...",
-        "delegate [--cwd PATH] [--json] ps [--harness HARNESS] [--group NAME] [--limit N]",
+        "delegate [--cwd PATH] [--json] ps [--harness HARNESS] [--group NAME] [--limit N] [--structural]",
         "delegate [--cwd PATH] [--json] run-output <handle> "
         "[--completion-report] [--stdout] [--stderr] [--tail N] [--max-chars N] "
         "[--raw] [--no-redact]",

delegate_agent_cli-0.28.0/src/delegate_agent/failover_state.py

@@ -0,0 +1,201 @@
+"""Persistent usage-limit state shared by Delegate and profile launchers."""
+
+from __future__ import annotations
+
+import contextlib
+import datetime
+import hashlib
+import os
+import re
+import time
+from collections.abc import Generator
+from pathlib import Path
+
+_VALID_TOOLS = frozenset({"codex"})
+_LEGACY_PROFILES = frozenset({"work", "personal"})
+_DEFAULT_COOLDOWN_SEC = 1800
+_LOCK_WAIT_SEC = 5.0
+_LOCK_STALE_SEC = 30.0
+
+
+def _root() -> Path:
+    return Path.home() / ".ai-profiles" / "runtime" / "failover"
+
+
+def _state_slug(tool: str, identity: str) -> str:
+    digest = hashlib.sha256(f"{tool}\0{identity}".encode()).hexdigest()
+    return digest[:32]
+
+
+def _state_file(tool: str, identity: str) -> Path:
+    return _root() / f"{tool}-{_state_slug(tool, identity)}.blocked-until"
+
+
+@contextlib.contextmanager
+def _lock_path(lock: Path) -> Generator[bool, None, None]:
+    deadline = time.monotonic() + _LOCK_WAIT_SEC
+    acquired = False
+    while not acquired:
+        try:
+            lock.mkdir()
+            acquired = True
+        except FileExistsError:
+            try:
+                if time.time() - lock.stat().st_mtime > _LOCK_STALE_SEC:
+                    lock.rmdir()
+                    continue
+            except OSError:
+                pass
+            if time.monotonic() >= deadline:
+                break
+            time.sleep(0.1)
+        except OSError:
+            break
+    try:
+        yield acquired
+    finally:
+        if acquired:
+            with contextlib.suppress(OSError):
+                lock.rmdir()
+
+
+def _lock(tool: str, identity: str) -> Generator[bool, None, None]:
+    return _lock_path(_root() / f"{tool}-{_state_slug(tool, identity)}.lock")
+
+
+def _valid(tool: str, identity: str | None) -> bool:
+    return tool in _VALID_TOOLS and isinstance(identity, str) and bool(identity)
+
+
+def _legacy_identity(profile_alias: str) -> str:
+    homes = {
+        "work": Path.home() / ".codex",
+        "personal": Path.home() / ".ai-profiles" / "runtime" / "codex" / "personal",
+    }
+    return f"auth={(homes[profile_alias] / 'auth.json').resolve(strict=False)}\0profile="
+
+
+def _legacy_profile(tool: str, identity: str, profile_alias: str | None) -> str | None:
+    if tool != "codex" or profile_alias not in _LEGACY_PROFILES:
+        return None
+    if identity != _legacy_identity(profile_alias):
+        return None
+    return profile_alias
+
+
+def _legacy_state_file(tool: str, profile_alias: str) -> Path:
+    return _root() / f"{tool}-{profile_alias}.blocked-until"
+
+
+def _legacy_lock(tool: str, profile_alias: str) -> Generator[bool, None, None]:
+    return _lock_path(_root() / f"{tool}-{profile_alias}.lock")
+
+
+def _read_block(state: Path, lock: Generator[bool, None, None]) -> int | None:
+    with lock as acquired:
+        if not acquired or not state.exists():
+            return None
+        raw = state.read_text().strip()
+        if not raw.isdigit() or int(raw) <= int(time.time()):
+            state.unlink(missing_ok=True)
+            return None
+        return int(raw)
+
+
+def _write_state(state: Path, lock: Generator[bool, None, None], proposed: int) -> None:
+    with lock as acquired:
+        if not acquired:
+            return
+        current = state.read_text().strip() if state.exists() else ""
+        expiry = max(proposed, int(current) if current.isdigit() else 0)
+        temp = state.with_name(f"{state.name}.tmp.{os.getpid()}")
+        temp.write_text(f"{expiry}\n")
+        os.chmod(temp, 0o600)
+        os.replace(temp, state)
+
+
+def check_blocked(
+    tool: str, identity: str | None, *, profile_alias: str | None = None
+) -> tuple[bool, int | None]:
+    if not _valid(tool, identity):
+        return False, None
+    assert identity is not None
+    try:
+        _root().mkdir(parents=True, exist_ok=True, mode=0o700)
+        expiries = [_read_block(_state_file(tool, identity), _lock(tool, identity))]
+        legacy = _legacy_profile(tool, identity, profile_alias)
+        if legacy is not None:
+            expiries.append(
+                _read_block(_legacy_state_file(tool, legacy), _legacy_lock(tool, legacy))
+            )
+        active = [expiry for expiry in expiries if expiry is not None]
+        if not active:
+            return False, None
+        return True, max(active)
+    except (OSError, ValueError):
+        return False, None
+
+
+def write_block(
+    tool: str,
+    identity: str | None,
+    reset_epoch: int | None = None,
+    *,
+    profile_alias: str | None = None,
+) -> None:
+    if not _valid(tool, identity):
+        return
+    assert identity is not None
+    try:
+        root = _root()
+        root.mkdir(parents=True, exist_ok=True, mode=0o700)
+        os.chmod(root, 0o700)
+        proposed = reset_epoch or int(time.time()) + _DEFAULT_COOLDOWN_SEC
+        _write_state(_state_file(tool, identity), _lock(tool, identity), proposed)
+        legacy = _legacy_profile(tool, identity, profile_alias)
+        if legacy is not None:
+            _write_state(_legacy_state_file(tool, legacy), _legacy_lock(tool, legacy), proposed)
+    except (OSError, ValueError):
+        pass
+
+
+def clear_block(tool: str, identity: str | None, *, profile_alias: str | None = None) -> None:
+    if not _valid(tool, identity):
+        return
+    assert identity is not None
+    try:
+        with _lock(tool, identity) as acquired:
+            if acquired:
+                _state_file(tool, identity).unlink(missing_ok=True)
+        legacy = _legacy_profile(tool, identity, profile_alias)
+        if legacy is not None:
+            with _legacy_lock(tool, legacy) as acquired:
+                if acquired:
+                    _legacy_state_file(tool, legacy).unlink(missing_ok=True)
+    except OSError:
+        pass
+
+
+def parse_reset_epoch(text: str) -> int | None:
+    match = re.search(r"try again at (\d{1,2}):(\d{2})\s*(AM|PM)", text, re.IGNORECASE)
+    if not match:
+        return None
+    hour, minute = int(match.group(1)), int(match.group(2))
+    if not 1 <= hour <= 12 or not 0 <= minute <= 59:
+        return None
+    if match.group(3).upper() == "PM" and hour != 12:
+        hour += 12
+    elif match.group(3).upper() == "AM" and hour == 12:
+        hour = 0
+    now = datetime.datetime.now()
+    reset = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
+    if reset <= now:
+        reset += datetime.timedelta(days=1)
+    return int(reset.timestamp())
+
+
+def epoch_to_human(epoch: int) -> str:
+    try:
+        return datetime.datetime.fromtimestamp(epoch).strftime("%H:%M")
+    except (OSError, OverflowError, ValueError):
+        return "?:??"

{delegate_agent_cli-0.27.0 → delegate_agent_cli-0.28.0}/src/delegate_agent/inspection_commands.py

@@ -8,6 +8,22 @@ from delegate_agent import command_errors, redaction, run_registry, snapshot_vie
 from delegate_agent import rendering as delegate_rendering
 from delegate_agent.json_types import JsonObject
 
+STRUCTURAL_RUN_KEYS = (
+    "runId",
+    "alias",
+    "harness",
+    "group",
+    "mode",
+    "modelAlias",
+    "modelResolved",
+    "rawStatus",
+    "effectiveStatus",
+    "status",
+    "terminalStatus",
+    "activityAt",
+    "initiatorRoot",
+)
+
 
 @dataclass(frozen=True)
 class SnapshotCommand:
@@ -28,6 +44,7 @@ class RunsCommand:
     limit: int | None = None
     older_than_days: int | None = None
     dry_run: bool = False
+    structural: bool = False
     json_mode: bool = False
 
 
@@ -121,7 +138,15 @@ def emit_runs(command: RunsCommand, *, workspace_path: str, stdout: TextIO) -> i
             group=command.group,
             limit=limit,
         )
-    summaries = [redaction.redact_value(summary) for summary in summaries]
+    if command.structural:
+        summaries = [
+            redaction.redact_value(
+                {key: summary[key] for key in STRUCTURAL_RUN_KEYS if key in summary}
+            )
+            for summary in summaries
+        ]
+    else:
+        summaries = [redaction.redact_value(summary) for summary in summaries]
     if command.json_mode:
         delegate_rendering.print_json(
             delegate_rendering.runs_json_payload(summaries, limit=limit, mode=mode),