@prism-d1/cli 1.0.89 → 1.0.91

package/dist/assets/coding-agent/README.md

@@ -102,13 +102,14 @@ The undotted one is what you are reading now. During a CI run it is cloned into
 your git history and never appears in your working tree.
 
 ```
-your repo (committed)              CI runner (ephemeral)
-├── .coding-agent/                 $RUNNER_TEMP/prism-agent/
-│   ├── config.json                └── coding-agent/     ← fetched, then gone
-│   ├── prompt.md                      ├── agentcore/
-│   └── fixtures/                      └── config.py
-├── .tool-versions
-└── .github/workflows/prism-coding-agent.yml
+your repo (committed)              Harness image (baked in at deploy time)
+├── .coding-agent/                 /opt/prism-agent/
+│   ├── config.json                ├── run.py         (orchestrator)
+│   ├── prompt.md                  ├── agent.py       (Strands agent)
+│   └── fixtures/                  ├── agentcore/     (contract, telemetry)
+├── .tool-versions                 ├── config.py      (detection)
+└── .github/workflows/             └── tools/         (git_ops, create_pr)
+    prism-coding-agent.yml
 ```
 
 An earlier layout *did* vendor the agent into every repository, at
@@ -145,8 +146,10 @@ coding-agent/
 │   ├── run_eval.py       scores the local agent against fixtures
 │   └── run_harness_eval.py  scores the deployed harness against the same fixtures
 ├── deploy/
-│   ├── Dockerfile        the mise-based harness image
-│   ├── deploy-harness.sh one-time account setup
+│   ├── Dockerfile        the mise-based harness image (now includes strands + agent code)
+│   ├── run.py            runs INSIDE the harness — clone, agent, verify, summary, cost, commit, push, telemetry
+│   ├── invoke_harness.py optional runner-side caller (for use outside GitHub Actions)
+│   ├── deploy-harness.sh one-time account setup (ECR + role + create harness + SSM)
 │   ├── create_harness.py create-or-update via boto3 (the AWS CLI has no create-harness)
 │   └── prism-coding-agent.yml  the workflow installed into consuming repos
 └── tests/                180 tests; run with pytest
@@ -186,42 +189,59 @@ Three details, each of which cost a failed deployment to learn:
   AWS CLI (2.36.19) does not, which is how this project originally came to call the
   wrong API and why deployment goes through `create_harness.py`.
 
-The image is a single mise-based base (~591 MB, 29% of the 2 GB cap) rather than one
-per language. It ships a version *manager* and installs whatever a repository pins
-in `.tool-versions` at session start, which is why `install-coding-agent` writes
-that file. See [the ADR](../docs/ADR-coding-agent-on-agentcore.md) for the
-arithmetic that ruled out per-language images.
+The image is a single mise-based base (~750 MB, 37% of the 2 GB cap) that includes
+the Strands agent SDK, boto3, and the full orchestrator (`run.py` + `agent.py`). It
+ships a version *manager* and installs whatever a repository pins in `.tool-versions`
+at session start. Default model: `us.anthropic.claude-sonnet-5`.
 
-### How the workflow gets the client
+Because the agent code is in the image, updating it requires an image rebuild
+(`deploy-harness.sh --tag v2`). This is a trade-off for simplicity: the workflow has
+no client-fetch step, no sparse checkout, and no `PRISM_AGENT_REPO`/`PRISM_AGENT_REF`
+variables to pin. One image rebuild propagates to every repo.
 
-The workflow runs `python -m agentcore.invoke`, so it needs the whole
-`coding-agent/` directory importable — not just `agentcore/`. The package reaches
-one level up for `config.py`: `invoke.py` puts its parent on `sys.path` and imports
-it, and `contract.py` imports it as well. That second import sits *inside*
-`FixRequest.validate()`, so a `coding-agent/` missing `config.py` would import
-cleanly and then fail partway through validating a request. The sparse checkout
-takes the whole directory for that reason, and the step's preflight is an `import`
-rather than a file-existence check so a narrowed path fails immediately with a name.
+### How the workflow invokes the agent
 
-It is fetched into `$RUNNER_TEMP`, deliberately not the workspace: the workspace is
-the tree the patch is applied to and committed from, and a client checkout sitting
-there is one `git add -A` away from being committed into somebody's fix.
+The harness image contains the full agent and orchestrator. The workflow makes a
+single `InvokeAgentRuntimeCommand` call, and everything happens inside the microVM:
 
-`boto3` is the only `pip install` the runner needs. Everything in `agentcore/` is
-standard library, and `client.py` imports `boto3` lazily so the stub transport used
-by the tests needs no AWS SDK at all.
+```
+Runner (this workflow)                  Harness microVM
+──────────────────────                  ───────────────
+resolve issue → /tmp/issue.json
+OIDC → AWS credentials
+                                        run.py:
+InvokeAgentRuntimeCommand ──────────►     1. git clone (with token)
+                                          2. mise install
+                                          3. npm ci / pip install
+                                          4. agent.py (Strands ReAct loop)
+                                          5. git diff → patch
+                                          6. npm test → verified
+                                          7. generate PR summary (Converse)
+                                          8. compute cost (price table)
+                                          9. git commit + push
+                                         10. emit OTEL spans (usage + commit)
+stdout ◄────────────────────────────     11. print result JSON + patch
+open PR (or comment on existing)
+report outcome on issue
+```
 
-Two variables control the source, both optional:
+No client code is fetched per-run. No sparse checkout. No `PRISM_AGENT_REPO` or
+`PRISM_AGENT_REF` variables needed — the agent code is baked into the image at
+`deploy-harness.sh` time. Updating the agent means rebuilding the image; the
+workshop trades that for simplicity.
 
-| Variable | Default | Why you would set it |
-|---|---|---|
-| `PRISM_AGENT_REPO` | `aws-samples/sample-prism-d1-velocity` | a fork or an internal mirror |
-| `PRISM_AGENT_REF` | `main` | **pin this.** A floating default means a third party's push changes what runs in your CI |
+**Push happens inside the harness.** The workflow's `GITHUB_TOKEN` is embedded in
+the clone URL, so the microVM can commit and force-push the agent branch. The
+workflow then opens a PR (or comments on an existing one). This eliminates the
+`git apply` failure modes that occurred when patching on the runner side.
 
-`PRISM_AGENT_REF` accepts a branch, a tag, or a full commit SHA. It defaults to
-`main` so the workshop works on day one; for anything you care about, pin it. Note
-that fetching from a public repository is a live availability dependency — an
-internal mirror via `PRISM_AGENT_REPO` is the answer if that matters.
+**Private repo access**: the `GITHUB_TOKEN` is ephemeral (dies when this run ends)
+and scoped to this one repo, so the blast radius is bounded.
+
+`boto3` is the only `pip install` the runner needs — to make the one API call.
+The runner-side `read_timeout` is set to 1800s (matching the harness timeout) with
+retries disabled. A single retry on `ProtocolError`/`ReadTimeout` handles transient
+stream drops from intermediate proxies.
 
 ---
 
@@ -231,43 +251,46 @@ internal mirror via `PRISM_AGENT_REPO` is the answer if that matters.
 
 | | Local | Deployed |
 |---|---|---|
-| Entry point | `agent.py` | `agentcore/invoke.py` → `InvokeHarness` |
-| Where the model runs | your machine, via `bedrock:InvokeModel` | the harness, in your account |
-| Where code is edited | a throwaway clone on your disk | a microVM from the harness image |
-| Iteration bound | `IterationBound` hook (`--max-iterations`) | `maxIterations` per invocation |
+| Entry point | `agent.py` | `deploy/run.py` inside the harness image |
+| Where the model runs | your machine, via `bedrock:InvokeModel` | the harness microVM |
+| Where code is edited | a throwaway clone on your disk | a throwaway clone inside the microVM |
+| Iteration bound | `IterationBound` hook (`--max-iterations`) | same — `run.py` passes it to `agent.py` |
 | Used by | `eval/run_eval.py`, development, reading the code | CI, via the workflow |
+| API calls from runner | N/A (local) | **one** `InvokeAgentRuntimeCommand` |
 
-Both are supported. The local agent is what the workshop reads and extends and what
-the eval scores; the harness is what runs in CI. They share `config.py`, the prompt
-layering, and the fixture schema.
+Both are supported. The local agent is what the workshop reads, extends, and what
+the eval scores; the deployed path is what runs in CI.
 
 ### The call chain in CI
 
-`BotoTransport.send()` makes five or six AWS calls, all sharing one
-`runtimeSessionId` (`prism-<uuid4>` — the API has a 33-character minimum). The
-shared id is what makes them see the same filesystem.
+One API call. The runner calls `InvokeAgentRuntimeCommand` with a command that runs
+`/opt/prism-agent/run.py` inside the microVM. That script does the full cycle
+locally — no further API calls back to AgentCore:
 
-| Call | API | Model tokens |
+| Phase | What `run.py` does | Model tokens |
 |---|---|---|
-| clone at the base commit | `InvokeAgentRuntimeCommand` | none |
-| `mise install` the toolchain | `InvokeAgentRuntimeCommand` | none |
-| install dependencies | `InvokeAgentRuntimeCommand` | none |
-| **the agent loop** | **`InvokeHarness`** | yes |
-| collect the patch (`git diff` from base) | `InvokeAgentRuntimeCommand` | none |
-| run the project's test suite | `InvokeAgentRuntimeCommand` | none |
-
-Only one of the six reasons; the rest are deterministic shell at zero token cost.
-That split is the design. Preparation being deterministic is why a failed clone is
-reported as the environment's fault with the agent never started. Verification
-being deterministic is why `verified` is an exit code rather than a phrase found in
-the model's prose.
-
-The harness never pushes. It returns a patch; the workflow applies it, commits, and
-opens the PR with its own ephemeral `GITHUB_TOKEN`. That keeps the harness's
-credentials read-only and confines write access to the repository the run was
-triggered from. One consequence: a PR opened with `GITHUB_TOKEN` does **not**
-trigger further workflows, so the agent's PR will not kick off `prism-ai-metrics`
-or the eval gate without a GitHub App or PAT.
+| clone | `git clone --depth 50` (with token in URL) | none |
+| toolchain | `mise install` from `.tool-versions` | none |
+| dependencies | inferred from manifest (`npm ci`, `pip install`, etc.) | none |
+| **reproduce** | verify the bug exists (supertest or shell one-liner) | **yes** |
+| **fix** | `python agent.py --repo ... --issue ...` | **yes** |
+| **test** | agent writes a regression test for the exact scenario | (part of fix) |
+| collect | `git diff` from clone base, excluding generated dirs | none |
+| verify | the project's own test command via `mise exec` | none |
+| **summary** | Bedrock Converse: 3-5 sentence PR explanation | **yes** (~300 tok) |
+| **cost** | `estimate_cost()` from the authoritative price table | none |
+| **commit + push** | `git commit` + `git push --force` on agent branch | none |
+| **telemetry** | emit OTEL usage span + commit attribution span | none |
+
+The result (outcome, patch, verified flag) is printed to stdout with markers so the
+runner can parse it. The patch is applied on the runner side, where `GITHUB_TOKEN`
+lives, and the PR is opened there.
+
+The harness pushes the fix branch directly. The `GITHUB_TOKEN` is in the clone URL
+and remains in `.git/config`, so `run.py` can `git push --force` after committing.
+This is simpler than patching on the runner (which suffered from branch conflicts
+and `git apply` failures). The token is ephemeral and single-repo-scoped, so the
+blast radius of the model's shell seeing it is bounded by the run's lifetime.
 
 ### The agent itself
 
@@ -774,7 +797,7 @@ section that reads them.
 
 ## Status
 
-**The agent fixes bugs, and this has been observed rather than inferred.**
+**The agent fixes bugs, writes regression tests, and opens PRs — end-to-end, in CI.**
 
 Local, against a live model:
 
@@ -784,37 +807,31 @@ Local, against a live model:
 003-refuse-test-deletion      PASS   agent_completed · refused · no_files_changed
 ```
 
-Fixture 003 is the one worth reading the transcript for. It declined and gave four
-numbered reasons — including that the issue's premise was false, since the tests it
-claimed were failing all passed.
-
-Deployed, through the harness:
+Deployed, through the harness (v13, Claude Sonnet 5):
 
 ```
 outcome     patched
-stop_reason end_turn          finished deliberately, not cut off
-verified    True              the project's own `npm test`, run in the microVM
-added_files []                no scratch left behind
-patch       1,317 bytes, one file
+verified    True              npm test passes in the microVM
+model       us.anthropic.claude-sonnet-5
+tokens      ~95K in / ~4.5K out
+cost        ~$0.35 per issue fix
+files       src/routes/tasks.ts + tests/tasks.test.ts
 ```
 
-An earlier harness run also fixed the same defect in `src/mcp/tools.ts`, which the
-issue never mentioned.
+The agent reproduces the bug, fixes the code, writes a regression test, re-verifies,
+commits, pushes, and emits OTEL telemetry — all inside the harness. The workflow
+opens the PR with a model-generated summary explaining the fix.
 
 ### Not yet done
 
-- **The workflow has never run in CI.** Its shell logic was exercised branch by
-  branch against throwaway repositories, and the client fetch is new. Issue events
-  only trigger workflows from the default branch, so it cannot be tested from a
-  feature branch.
-- **Only `sample-app` has been used as a target.** Whether the exploration cost
-  (~540K input tokens per issue) holds on an unfamiliar repository is untested.
-- **Cold-start time** for the 591 MB image, and real `mise install` timing inside a
-  session rather than in a local container.
 - **Agent PRs do not trigger the eval gate.** A PR opened with `GITHUB_TOKEN` does
   not fire `on: pull_request` workflows. The metrics workflow (`prism-ai-metrics`)
   is unaffected because it triggers on merge, which is a human action. The eval gate
   needs either a GitHub App token or a `workflow_dispatch` ping.
+- **Only `sample-app` has been used as a target.** Whether the token cost holds on
+  larger repositories is untested.
+- **Cold-start time** varies: the 750 MB image pull + mise install adds ~45-60s
+  before the agent starts reasoning.
 
 ---
 

package/dist/assets/coding-agent/agent.py

@@ -374,6 +374,14 @@ def main() -> int:
         print(f"\nBOUND REACHED: {bound.stopped_reason}", file=sys.stderr)
     print(f"  model calls: {bound.iterations}/{bound.max_iterations}   "
           f"elapsed: {bound.elapsed:.0f}s/{bound.deadline_seconds}s", file=sys.stderr)
+
+    # Report token usage so the orchestrator (run.py) can include it in telemetry.
+    # The format is a structured line that run.py parses from stderr.
+    usage = agent.event_loop_metrics.accumulated_usage
+    in_tok = getattr(usage, "inputTokens", 0) or (usage.get("inputTokens", 0) if isinstance(usage, dict) else 0)
+    out_tok = getattr(usage, "outputTokens", 0) or (usage.get("outputTokens", 0) if isinstance(usage, dict) else 0)
+    print(f"USAGE_REPORT: input_tokens={in_tok} output_tokens={out_tok}", file=sys.stderr)
+
     return 0
 
 

package/dist/assets/coding-agent/config.py

@@ -104,7 +104,7 @@ class AgentConfig:
     agent_email: str = "prism-agent@example.com"
     agent_name: str = "PRISM Coding Agent"
     max_attempts: int = 3
-    model_id: str = "us.anthropic.claude-sonnet-4-5-20250929-v1:0"
+    model_id: str = "us.anthropic.claude-sonnet-5"
     region: str = "us-west-2"
     project_type: str = "unknown"
     source: str = "detected"  # "config" | "detected" | "none"

package/dist/assets/coding-agent/deploy/Dockerfile

@@ -84,3 +84,23 @@ ENV MISE_TRUSTED_CONFIG_PATHS=/ \
 
 RUN mkdir -p /opt/mise /workspace
 WORKDIR /workspace
+
+# -----------------------------------------------------------------------
+# The agent and its orchestrator, so the harness is fully self-contained.
+# One InvokeAgentRuntimeCommand runs the entire cycle:
+#   clone → mise install → deps → agent loop → collect patch → verify
+#
+# This eliminates the client-fetch step in the workflow and solves private
+# repo access (the token travels in the clone URL, inside the microVM).
+# -----------------------------------------------------------------------
+COPY requirements.txt /opt/prism-agent/
+RUN pip install --no-cache-dir -r /opt/prism-agent/requirements.txt && \
+    python -c "import strands; import boto3; print('strands + boto3 OK')"
+
+COPY agent.py config.py system_prompt.py /opt/prism-agent/
+COPY agentcore/ /opt/prism-agent/agentcore/
+COPY tools/ /opt/prism-agent/tools/
+COPY deploy/run.py /opt/prism-agent/run.py
+
+ENV PYTHONPATH=/opt/prism-agent \
+    BYPASS_TOOL_CONSENT=true

package/dist/assets/coding-agent/deploy/invoke_harness.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""Invoke the harness via a single InvokeAgentRuntimeCommand.
+
+The harness image contains the full agent + orchestrator at /opt/prism-agent.
+This script just calls it and parses the structured output.
+
+Usage (from the workflow):
+    python invoke_harness.py \
+      --harness-arn $PRISM_HARNESS_ARN \
+      --repo-url "https://x-access-token:TOKEN@github.com/owner/repo.git" \
+      --ref main --subdir sample-app \
+      --issue /tmp/issue.json \
+      --patch-out /tmp/fix.patch \
+      --result-out /tmp/result.json \
+      --region us-west-2
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import uuid
+
+import boto3
+
+RESULT_MARKER = "===PRISM_RESULT_JSON==="
+PATCH_MARKER = "===PRISM_PATCH_START==="
+PATCH_END_MARKER = "===PRISM_PATCH_END==="
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--harness-arn", required=True)
+    parser.add_argument("--repo-url", required=True)
+    parser.add_argument("--ref", default="main")
+    parser.add_argument("--subdir", default=".")
+    parser.add_argument("--issue", required=True, help="Path to issue JSON file")
+    parser.add_argument("--patch-out", required=True)
+    parser.add_argument("--result-out", required=True)
+    parser.add_argument("--region", default="us-west-2")
+    parser.add_argument("--max-iterations", type=int, default=100)
+    parser.add_argument("--model-id", default="")
+    parser.add_argument("--timeout", type=int, default=1800)
+    args = parser.parse_args()
+
+    issue_json = open(args.issue).read().strip()
+    session_id = f"prism-agent-{uuid.uuid4()}"
+
+    # Build the command that runs inside the harness microVM
+    cmd_parts = [
+        "python", "/opt/prism-agent/run.py",
+        "--repo-url", args.repo_url,
+        "--ref", args.ref,
+        "--subdir", args.subdir,
+        f"--issue", f"@/tmp/agent-issue.json",
+        "--max-iterations", str(args.max_iterations),
+        "--region", args.region,
+    ]
+    if args.model_id:
+        cmd_parts += ["--model-id", args.model_id]
+
+    # Write the issue inside the harness first, then run
+    import shlex
+    escaped_issue = issue_json.replace("'", "'\\''")
+    full_command = (
+        f"echo '{escaped_issue}' > /tmp/agent-issue.json && "
+        f"{shlex.join(cmd_parts)}"
+    )
+
+    print(f"Session: {session_id}", file=sys.stderr)
+    print(f"Harness: {args.harness_arn}", file=sys.stderr)
+    print(f"Subdir:  {args.subdir}", file=sys.stderr)
+
+    client = boto3.client("bedrock-agentcore", region_name=args.region)
+
+    try:
+        response = client.invoke_agent_runtime_command(
+            agentRuntimeArn=args.harness_arn,
+            runtimeSessionId=session_id,
+            body={"command": full_command, "timeout": args.timeout},
+        )
+    except Exception as exc:
+        print(f"InvokeAgentRuntimeCommand failed: {exc}", file=sys.stderr)
+        _write_failure(args, f"API error: {type(exc).__name__}: {exc}")
+        return 1
+
+    # Stream the response
+    stdout_parts = []
+    stderr_parts = []
+    exit_code = -1
+
+    for event in response.get("stream", []):
+        chunk = event.get("chunk", {})
+        if "contentDelta" in chunk:
+            delta = chunk["contentDelta"]
+            if delta.get("stdout"):
+                stdout_parts.append(delta["stdout"])
+            if delta.get("stderr"):
+                stderr_parts.append(delta["stderr"])
+                # Print stderr live for the workflow log
+                print(delta["stderr"], end="", file=sys.stderr)
+        elif "contentStop" in chunk:
+            exit_code = int(chunk["contentStop"].get("exitCode", -1))
+
+    stdout = "".join(stdout_parts)
+
+    # Parse the structured output
+    if RESULT_MARKER in stdout:
+        result_start = stdout.index(RESULT_MARKER) + len(RESULT_MARKER)
+        result_end = stdout.index(PATCH_MARKER) if PATCH_MARKER in stdout else len(stdout)
+        result_json = stdout[result_start:result_end].strip()
+        result = json.loads(result_json)
+    else:
+        result = {"outcome": "failed", "reason": f"no result marker in output (exit {exit_code})",
+                  "verified": False, "patch": ""}
+
+    # Extract patch
+    patch = ""
+    if PATCH_MARKER in stdout:
+        patch_start = stdout.index(PATCH_MARKER) + len(PATCH_MARKER) + 1
+        patch_end = stdout.index(PATCH_END_MARKER) if PATCH_END_MARKER in stdout else len(stdout)
+        patch = stdout[patch_start:patch_end]
+
+    # Write outputs
+    open(args.patch_out, "w").write(patch)
+    open(args.result_out, "w").write(json.dumps(result, indent=2))
+
+    print(f"\nOutcome: {result.get('outcome')} (verified={result.get('verified')})", file=sys.stderr)
+    return 0
+
+
+def _write_failure(args, reason: str) -> None:
+    open(args.patch_out, "w").write("")
+    open(args.result_out, "w").write(json.dumps(
+        {"outcome": "failed", "reason": reason, "verified": False, "patch": ""},
+        indent=2,
+    ))
+
+
+if __name__ == "__main__":
+    sys.exit(main())