@prism-d1/cli 1.0.84 → 1.0.86

package/dist/assets/coding-agent/deploy/deploy-harness.sh

@@ -0,0 +1,201 @@
+#!/usr/bin/env bash
+#
+# deploy-harness.sh — build the agent image and create the AgentCore harness in
+# your own AWS account. Run once per account/region, not per repository.
+#
+# Every repository that installs the coding agent then points at the one harness
+# ARN this prints, via the PRISM_HARNESS_ARN org variable. Nothing about the agent
+# is copied into those repositories.
+#
+#   ./deploy-harness.sh --account 123456789012 --region us-west-2
+#   ./deploy-harness.sh --profile my-dev --tag v2          # rebuild and update
+#
+# Idempotent: re-running rebuilds the image, pushes a new tag, and updates the
+# existing harness rather than creating a second one.
+#
+# WHY THIS IS A SCRIPT AND NOT A CDK STACK
+#   CloudFormation has no resource type for an AgentCore harness, and the AWS CLI
+#   has no `create-harness` (checked on 2.36.19 — the operation exists only in
+#   boto3). So the create/update call goes through a small inline Python block.
+#   When a CFN resource type ships, this becomes a stack.
+
+set -euo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+AGENT_DIR="$(dirname "${HERE}")"
+
+REGION="us-west-2"
+ACCOUNT=""
+PROFILE=""
+TAG="v1"
+NAME="PrismCodingAgent"
+ECR_REPO="prism/coding-agent-harness"
+ROLE_NAME="PrismCodingAgentHarnessRole"
+MODEL_ID="us.anthropic.claude-sonnet-4-5-20250929-v1:0"
+# Matches agentcore.contract.MAX_ITERATIONS. The client passes maxIterations on
+# every InvokeHarness call, so this is only the fallback for callers that do not.
+MAX_ITERATIONS=100
+TIMEOUT_SECONDS=1800
+
+usage() {
+  sed -n '2,25p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'
+  exit "${1:-0}"
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --region)  REGION="$2"; shift 2 ;;
+    --account) ACCOUNT="$2"; shift 2 ;;
+    --profile) PROFILE="$2"; shift 2 ;;
+    --tag)     TAG="$2"; shift 2 ;;
+    --name)    NAME="$2"; shift 2 ;;
+    --model)   MODEL_ID="$2"; shift 2 ;;
+    -h|--help) usage 0 ;;
+    *) echo "Unknown argument: $1" >&2; usage 1 ;;
+  esac
+done
+
+[[ -n "${PROFILE}" ]] && export AWS_PROFILE="${PROFILE}"
+export AWS_DEFAULT_REGION="${REGION}"
+
+for tool in aws docker python3; do
+  command -v "${tool}" >/dev/null || { echo "Missing required tool: ${tool}" >&2; exit 1; }
+done
+python3 -c 'import boto3' 2>/dev/null || {
+  echo "boto3 is required (the AWS CLI has no create-harness): pip install boto3" >&2
+  exit 1
+}
+
+if [[ -z "${ACCOUNT}" ]]; then
+  ACCOUNT="$(aws sts get-caller-identity --query Account --output text)"
+fi
+REGISTRY="${ACCOUNT}.dkr.ecr.${REGION}.amazonaws.com"
+IMAGE="${REGISTRY}/${ECR_REPO}:${TAG}"
+
+echo "Account : ${ACCOUNT}"
+echo "Region  : ${REGION}"
+echo "Image   : ${IMAGE}"
+echo "Harness : ${NAME}"
+echo
+
+# ---- 1. ECR repository -------------------------------------------------------
+echo "==> ECR repository"
+if ! aws ecr describe-repositories --repository-names "${ECR_REPO}" >/dev/null 2>&1; then
+  aws ecr create-repository \
+    --repository-name "${ECR_REPO}" \
+    --image-scanning-configuration scanOnPush=true \
+    --encryption-configuration encryptionType=AES256 >/dev/null
+  echo "    created ${ECR_REPO}"
+else
+  echo "    ${ECR_REPO} exists"
+fi
+
+# ---- 2. Build and push (arm64) ----------------------------------------------
+# AgentCore runs arm64. Building the host's native arch on an x86 laptop produces
+# an image the harness cannot start, and the failure surfaces at invoke time
+# rather than at build time -- so the platform is pinned explicitly.
+echo "==> Build and push (linux/arm64)"
+aws ecr get-login-password --region "${REGION}" \
+  | docker login --username AWS --password-stdin "${REGISTRY}" >/dev/null
+docker buildx build \
+  --platform linux/arm64 \
+  --tag "${IMAGE}" \
+  --file "${HERE}/Dockerfile" \
+  --push \
+  "${HERE}"
+echo "    pushed ${IMAGE}"
+
+# ---- 3. Execution role -------------------------------------------------------
+echo "==> Execution role ${ROLE_NAME}"
+TRUST='{"Version":"2012-10-17","Statement":[{"Effect":"Allow",
+  "Principal":{"Service":"bedrock-agentcore.amazonaws.com"},"Action":"sts:AssumeRole"}]}'
+
+# The memory statement is the one that is easy to miss and hard to diagnose. A
+# harness provisions its own AgentCore Memory resource on first invocation, so the
+# actions cannot be scoped to an ARN that exists when the role is written --
+# omitting them fails the first real invocation as AccessDenied on ListEvents
+# against a resource that did not exist yet, wrapped in a runtimeClientError.
+POLICY=$(cat <<JSON
+{"Version":"2012-10-17","Statement":[
+ {"Sid":"EcrPull","Effect":"Allow","Action":[
+   "ecr:GetAuthorizationToken","ecr:BatchCheckLayerAvailability",
+   "ecr:GetDownloadUrlForLayer","ecr:BatchGetImage"],"Resource":"*"},
+ {"Sid":"Logs","Effect":"Allow","Action":[
+   "logs:CreateLogGroup","logs:CreateLogStream","logs:PutLogEvents",
+   "logs:DescribeLogGroups","logs:DescribeLogStreams"],
+  "Resource":"arn:aws:logs:${REGION}:${ACCOUNT}:log-group:/aws/bedrock-agentcore/*"},
+ {"Sid":"KmsForLogGroups","Effect":"Allow","Action":["kms:DescribeKey"],"Resource":"*"},
+ {"Sid":"InvokeModel","Effect":"Allow","Action":[
+   "bedrock:InvokeModel","bedrock:InvokeModelWithResponseStream",
+   "bedrock:Converse","bedrock:ConverseStream"],"Resource":"*"},
+ {"Sid":"HarnessMemory","Effect":"Allow","Action":[
+   "bedrock-agentcore:ListEvents","bedrock-agentcore:CreateEvent",
+   "bedrock-agentcore:GetEvent","bedrock-agentcore:DeleteEvent",
+   "bedrock-agentcore:ListActors","bedrock-agentcore:ListSessions",
+   "bedrock-agentcore:RetrieveMemoryRecords","bedrock-agentcore:ListMemoryRecords",
+   "bedrock-agentcore:GetMemoryRecord","bedrock-agentcore:GetMemory",
+   "bedrock-agentcore:CreateMemory","bedrock-agentcore:ListMemories"],
+  "Resource":"*"}
+]}
+JSON
+)
+
+if ! aws iam get-role --role-name "${ROLE_NAME}" >/dev/null 2>&1; then
+  aws iam create-role --role-name "${ROLE_NAME}" \
+    --assume-role-policy-document "${TRUST}" \
+    --description "Execution role for the PRISM coding agent AgentCore harness" >/dev/null
+  echo "    created ${ROLE_NAME}"
+else
+  echo "    ${ROLE_NAME} exists"
+fi
+aws iam put-role-policy --role-name "${ROLE_NAME}" \
+  --policy-name PrismCodingAgentHarness --policy-document "${POLICY}"
+ROLE_ARN="arn:aws:iam::${ACCOUNT}:role/${ROLE_NAME}"
+echo "    policy applied"
+
+# ---- 4. Create or update the harness ----------------------------------------
+echo "==> Harness"
+HARNESS_ARN=$(
+  AGENTCORE_REGION="${REGION}" \
+  AGENTCORE_NAME="${NAME}" \
+  AGENTCORE_IMAGE="${IMAGE}" \
+  AGENTCORE_ROLE="${ROLE_ARN}" \
+  AGENTCORE_MODEL="${MODEL_ID}" \
+  AGENTCORE_MAX_ITERATIONS="${MAX_ITERATIONS}" \
+  AGENTCORE_TIMEOUT="${TIMEOUT_SECONDS}" \
+  python3 "${HERE}/create_harness.py"
+)
+echo "    ${HARNESS_ARN}"
+
+# ---- 5. Write the ARN to SSM so it is discoverable without manual copying ----
+echo "==> SSM parameter"
+aws ssm put-parameter \
+  --name /prism/d1/harness-arn \
+  --value "${HARNESS_ARN}" \
+  --type String \
+  --overwrite \
+  --description "AgentCore harness ARN — written by deploy-harness.sh" >/dev/null
+echo "    /prism/d1/harness-arn = ${HARNESS_ARN}"
+
+cat <<EOF
+
+✅ Harness ready
+
+  ${HARNESS_ARN}
+
+The ARN is stored in SSM at /prism/d1/harness-arn. For the workflow's early-fail
+check (which runs before AWS credentials are available), also set it as a GitHub
+org variable — this is the one variable that cannot come from SSM alone:
+
+  gh variable set PRISM_HARNESS_ARN --org <your-org> \\
+    --body "${HARNESS_ARN}"
+
+An ARN is an identifier, not a credential, so it belongs in a variable rather
+than a secret. Then, per repository:
+
+  prism-cli bootstrapper install-coding-agent
+  gh label create agent-fix --description "Hand this issue to the PRISM coding agent"
+
+Nothing about the agent is copied into those repositories -- the workflow fetches
+the thin client at run time and calls this harness.
+EOF

package/dist/assets/coding-agent/deploy/prism-coding-agent.yml

@@ -0,0 +1,399 @@
+# prism-coding-agent.yml — Autonomous issue → fix → PR, via an AgentCore harness.
+#
+# Installed by: prism-cli bootstrapper install-coding-agent
+#
+# This file deliberately does NOT live in bootstrapper/github-workflows/.
+# install-github-workflows copies every .yml in that directory, so putting it
+# there would hand an autonomous, Bedrock-billing, branch-pushing agent to every
+# repo that ran the workflow installer.
+#
+#
+# WHAT RUNS WHERE
+#
+# The agent runs on AgentCore, not here. This workflow is the thin client: it
+# resolves the issue, invokes the harness, applies the patch it returns, and opens
+# a pull request. That split is what keeps the harness's credentials read-only --
+# it never pushes, so it needs no write access to any repository, and the token
+# that opens the PR is this run's own ephemeral, repo-scoped GITHUB_TOKEN.
+#
+# One harness serves every toolchain. It ships mise and installs what the
+# repository declares in .tool-versions at session start, so there is no
+# per-language routing to configure here.
+#
+#
+# AUTHORIZATION MODEL
+#
+# The trigger is `issues: [labeled]`, gated on a specific label. That is the
+# security control, and it is load-bearing: anybody with a GitHub account can
+# open an issue in a public repo, but applying a label requires triage
+# permission or above. Triggering on `issues: [opened]` instead would let any
+# stranger spend your Bedrock budget and put a branch in your repository.
+#
+# NOTE: `issues` events only trigger a workflow run if this file exists on the
+# DEFAULT branch. You cannot test changes to it from a feature branch -- nothing
+# fires, and nothing reports why. Merge first.
+#
+#
+# REQUIRED SETUP
+#   - prism-cli bootstrapper setup-github-oidc   (grants bedrock:InvokeModel)
+#   - Repository secret PRISM_METRICS_ROLE_ARN
+#   - Repository or org variable PRISM_HARNESS_ARN (an ARN is an identifier, not
+#     a credential, so it belongs in `vars` -- and an org variable is inherited by
+#     every repo, which is what "deploy the harness once" should feel like)
+#   - A label matching AGENT_LABEL below, created in the repo
+#   - .coding-agent/config.json committed (written by install-coding-agent)
+#
+# The agent is NOT vendored into this repository. Only config.json, prompt.md,
+# fixtures/ and this file live here; the orchestrator client is fetched at run
+# time from the sample repo, and the agent itself runs in an AgentCore harness in
+# your own account. That means an agent fix reaches every repo without an N-repo
+# migration, which vendoring could not offer.
+#
+# Pin PRISM_AGENT_REF to a tag or commit SHA for anything you care about. It
+# defaults to `main` so the workshop works on day one, but a floating default
+# means a third party's push can change what runs in your CI.
+
+name: PRISM Coding Agent
+
+on:
+  issues:
+    types: [labeled]
+  workflow_dispatch:
+    inputs:
+      issue_number:
+        description: 'Issue number to fix'
+        required: true
+        type: string
+
+env:
+  PRISM_AWS_REGION: us-west-2
+  PRISM_REPO: github.com/${{ github.repository }}
+  PRISM_HARNESS_ARN: ${{ vars.PRISM_HARNESS_ARN }}
+  # Where the orchestrator client comes from. Overridable as repo/org variables so
+  # a fork, an internal mirror, or a pinned SHA needs no edit to this file.
+  PRISM_AGENT_REPO: ${{ vars.PRISM_AGENT_REPO || 'aws-samples/sample-prism-d1-velocity' }}
+  PRISM_AGENT_REF: ${{ vars.PRISM_AGENT_REF || 'main' }}
+
+permissions:
+  id-token: write       # OIDC → AWS
+  contents: write       # push the fix branch
+  pull-requests: write  # open the PR
+  issues: write         # comment the outcome back on the issue
+
+jobs:
+  fix-issue:
+    # On the label path, run only for the agent label. Any other label added to
+    # any issue also fires this workflow, so this condition is what keeps the
+    # job from running on every triage action in the repository.
+    #
+    # The label is a literal here, not an env var, because the `env` context is
+    # not available in a job-level `if`. An AGENT_LABEL variable above would look
+    # configurable and change nothing — if you rename the label, edit this line.
+    if: >-
+      github.event_name == 'workflow_dispatch' ||
+      github.event.label.name == 'agent-fix'
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          fetch-depth: 0
+
+      - name: Fail early if no harness is configured
+        run: |
+          set -euo pipefail
+          if [[ -z "${PRISM_HARNESS_ARN}" ]]; then
+            echo "::warning::PRISM_HARNESS_ARN variable is not set. Will try SSM after OIDC." \
+                 "coding-agent/deploy/Dockerfile and set the repository or org" \
+                 "variable. Failing now rather than after commenting on the issue."
+            exit 1
+          fi
+
+      - name: Resolve the issue to work on
+        id: issue
+        env:
+          GH_TOKEN: ${{ github.token }}
+          DISPATCH_NUMBER: ${{ inputs.issue_number }}
+        run: |
+          set -euo pipefail
+
+          # Both branches write the same shape: a GitHub event payload with the
+          # issue under an `issue` key, which is what agentcore.invoke reads. The
+          # dispatch branch has to wrap it, because `gh issue view` returns a
+          # bare issue object.
+          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+            if ! [[ "${DISPATCH_NUMBER}" =~ ^[0-9]+$ ]]; then
+              echo "::error::issue_number must be numeric, got '${DISPATCH_NUMBER}'"
+              exit 1
+            fi
+            gh issue view "${DISPATCH_NUMBER}" --json number,title,body,labels \
+              | jq '{issue: .}' > /tmp/issue.json
+          else
+            # Read from the payload rather than re-fetching: avoids a race where
+            # the issue is edited between the label and this step.
+            jq '{issue: (.issue | {number, title, body, labels})}' \
+              "${GITHUB_EVENT_PATH}" > /tmp/issue.json
+          fi
+
+          NUMBER=$(jq -r '.issue.number' /tmp/issue.json)
+          echo "number=${NUMBER}" >> "$GITHUB_OUTPUT"
+          echo "Working on issue #${NUMBER}: $(jq -r '.issue.title' /tmp/issue.json)"
+
+      - name: Acknowledge on the issue
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh issue comment "${{ steps.issue.outputs.number }}" \
+            --body "🤖 PRISM coding agent picked this up — [run log](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})."
+
+      - name: Set up Python
+        uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        with:
+          python-version: '3.12'
+
+      - name: Install runner dependencies
+        run: |
+          set -euo pipefail
+          sudo apt-get update -qq && sudo apt-get install -y -qq jq
+          # Only boto3 -- the agent's own dependencies live in the harness image,
+          # not here. This runner never loads a model.
+          pip install --quiet boto3
+
+      - name: Fetch the orchestrator client
+        id: client
+        env:
+          AGENT_REPO: ${{ env.PRISM_AGENT_REPO }}
+          AGENT_REF: ${{ env.PRISM_AGENT_REF }}
+        run: |
+          set -euo pipefail
+          # Cloned into RUNNER_TEMP, NOT the workspace. actions/checkout can only
+          # write under GITHUB_WORKSPACE, and anything there is inside the tree the
+          # agent's patch is applied to and committed from -- a client checkout
+          # sitting in the working tree is one `git add -A` away from being
+          # committed into somebody's fix.
+          DEST="${RUNNER_TEMP}/prism-agent"
+          rm -rf "${DEST}"
+          mkdir -p "${DEST}"
+
+          # init + fetch rather than `clone --branch`, because --branch takes a
+          # branch or tag and rejects a commit SHA -- which is exactly what a repo
+          # that has pinned PRISM_AGENT_REF will be passing.
+          git -C "${DEST}" init -q
+          git -C "${DEST}" remote add origin "https://github.com/${AGENT_REPO}.git"
+          git -C "${DEST}" sparse-checkout init --cone
+          git -C "${DEST}" sparse-checkout set coding-agent
+          git -C "${DEST}" fetch -q --depth 1 origin "${AGENT_REF}"
+          git -C "${DEST}" checkout -q FETCH_HEAD
+
+          CLIENT="${DEST}/coding-agent"
+          # Preflight by importing rather than by checking that files exist. The
+          # runtime dependency is the whole `coding-agent/` directory, not just the
+          # `agentcore/` package: invoke.py puts its parent on sys.path and imports
+          # `config`, and contract.py imports it too -- from inside
+          # FixRequest.validate(), so a missing config.py would not surface until a
+          # request was already being validated. An import check covers both, plus
+          # any module inside the package that a narrowed sparse path dropped.
+          #
+          # `python -c` rather than a heredoc: a heredoc terminator has to sit at
+          # column 0, which inside a YAML block scalar means breaking out of the
+          # block and invalidating the workflow file.
+          if ! ( cd "${CLIENT}" && python -c "import sys; sys.path.insert(0, '.'); import agentcore.invoke; import config" ); then
+            echo "::error::${AGENT_REPO}@${AGENT_REF} does not provide a usable" \
+                 "coding-agent/ client (agentcore/ and config.py are both required)"
+            exit 1
+          fi
+          echo "dir=${CLIENT}" >> "$GITHUB_OUTPUT"
+          echo "Client ${AGENT_REPO}@$(git -C "${DEST}" rev-parse --short FETCH_HEAD)"
+
+      - name: Configure AWS credentials (OIDC)
+        uses: aws-actions/configure-aws-credentials@b47578312673ae6fa5b5096b330d9fbac3d116df # v4.2.1
+        with:
+          role-to-assume: ${{ secrets.PRISM_METRICS_ROLE_ARN }}
+          aws-region: ${{ env.PRISM_AWS_REGION }}
+
+      - name: Load telemetry config from SSM
+        # One source of truth: CDK writes these at deploy time, so they cannot
+        # drift from what's actually deployed. Falls back gracefully — a missing
+        # parameter means telemetry is unconfigured, not that the run fails.
+        run: |
+          set -euo pipefail
+          read_param() {
+            aws ssm get-parameter --name "$1" --query Parameter.Value --output text 2>/dev/null || echo ""
+          }
+          PRISM_COLLECTOR_URL=$(read_param /prism/d1/collector-url)
+          PRISM_OIDC_TOKEN_ENDPOINT=$(read_param /prism/d1/token-endpoint)
+          PRISM_AGENT_SECRET_ID=$(read_param /prism/d1/agent-secret-id)
+          echo "PRISM_COLLECTOR_URL=${PRISM_COLLECTOR_URL}" >> "$GITHUB_ENV"
+          echo "PRISM_OIDC_TOKEN_ENDPOINT=${PRISM_OIDC_TOKEN_ENDPOINT}" >> "$GITHUB_ENV"
+          echo "PRISM_AGENT_SECRET_ID=${PRISM_AGENT_SECRET_ID}" >> "$GITHUB_ENV"
+          # Harness ARN: the GitHub variable is the primary (pre-OIDC early-fail),
+          # but if it was empty (e.g. fork with no org vars), SSM is the fallback.
+          if [[ -z "${PRISM_HARNESS_ARN}" ]]; then
+            PRISM_HARNESS_ARN=$(read_param /prism/d1/harness-arn)
+            if [[ -n "${PRISM_HARNESS_ARN}" ]]; then
+              echo "PRISM_HARNESS_ARN=${PRISM_HARNESS_ARN}" >> "$GITHUB_ENV"
+              echo "Harness ARN loaded from SSM (GitHub variable was empty)"
+            fi
+          fi
+          if [[ -n "${PRISM_COLLECTOR_URL}" ]]; then
+            echo "Telemetry: ${PRISM_COLLECTOR_URL} (secret: ${PRISM_AGENT_SECRET_ID})"
+          else
+            echo "Telemetry: not configured (SSM params empty or missing)"
+          fi
+
+      - name: Invoke the harness
+        id: invoke
+        env:
+          PRISM_HARNESS_ARN: ${{ env.PRISM_HARNESS_ARN }}
+        run: |
+          if [[ -z "${PRISM_HARNESS_ARN}" ]]; then
+            echo "::error::No harness ARN available (checked GitHub variable AND SSM /prism/d1/harness-arn)."
+            echo "::error::Run coding-agent/deploy/deploy-harness.sh and set the org variable."
+            exit 1
+          fi
+          # GitHub runs `run:` blocks under `bash -e`, so a non-zero exit would
+          # end the step and skip straight past reporting. `set +e` keeps the exit
+          # code as data instead of as control flow.
+          set -o pipefail
+          set +e
+          # --repo is the checkout under test, which is NOT the working directory:
+          # this step runs from the client, and config.json lives in the target
+          # repo. Passing `.` here would resolve to the client and fail config
+          # loading with a confusing "no .coding-agent/config.json".
+          python -m agentcore.invoke \
+            --repo "${GITHUB_WORKSPACE}" \
+            --github-event /tmp/issue.json \
+            --patch-out /tmp/fix.patch \
+            --result-out /tmp/result.json \
+            --transcript-out /tmp/agent-transcript.log \
+            --repo-url "${{ github.server_url }}/${{ github.repository }}.git" \
+            --ref "${{ github.event.repository.default_branch }}" \
+            --region "${PRISM_AWS_REGION}" \
+            2>&1 | tee /tmp/invoke.log
+          EXIT_CODE=$?
+          set -e
+          echo "exit_code=${EXIT_CODE}" >> "$GITHUB_OUTPUT"
+
+          OUTCOME=$(jq -r '.outcome // "failed"' /tmp/result.json 2>/dev/null || echo failed)
+          echo "outcome=${OUTCOME}" >> "$GITHUB_OUTPUT"
+          VERIFIED=$(jq -r '.verified // false' /tmp/result.json 2>/dev/null || echo false)
+          echo "verified=${VERIFIED}" >> "$GITHUB_OUTPUT"
+          echo "Harness outcome: ${OUTCOME} (verified=${VERIFIED}, exit ${EXIT_CODE})"
+        working-directory: ${{ steps.client.outputs.dir }}
+
+      - name: Apply the patch
+        id: apply
+        if: steps.invoke.outputs.outcome == 'patched'
+        run: |
+          set -euo pipefail
+          BRANCH="agent/issue-${{ steps.issue.outputs.number }}"
+          git switch -c "${BRANCH}"
+
+          # --check first so a stale or malformed patch is reported as such rather
+          # than leaving a half-applied tree behind.
+          if ! git apply --check /tmp/fix.patch; then
+            echo "::error::the returned patch does not apply to this tree"
+            echo "applied=false" >> "$GITHUB_OUTPUT"
+            exit 1
+          fi
+          git apply /tmp/fix.patch
+
+          NAME=$(jq -r '.agent_name // "PRISM Coding Agent"' .coding-agent/config.json)
+          EMAIL=$(jq -r '.agent_email // "prism-agent@example.com"' .coding-agent/config.json)
+          SUMMARY=$(jq -r '.summary // "Autonomous fix"' /tmp/result.json)
+
+          git -c "user.name=${NAME}" -c "user.email=${EMAIL}" commit -a -m "$(printf 'fix: %s\n\n%s\n\nCloses #%s\n' \
+            "$(jq -r '.issue.title' /tmp/issue.json)" \
+            "${SUMMARY}" \
+            "${{ steps.issue.outputs.number }}")"
+
+          echo "branch=${BRANCH}" >> "$GITHUB_OUTPUT"
+          echo "applied=true" >> "$GITHUB_OUTPUT"
+          echo "files=$(git diff --name-only HEAD~1 HEAD | tr '\n' ' ')" >> "$GITHUB_OUTPUT"
+          echo "sha=$(git rev-parse HEAD)" >> "$GITHUB_OUTPUT"
+          git log --oneline -1
+
+      - name: Emit commit attribution
+        # After the commit, because the SHA does not exist before it -- the harness
+        # returns a patch and this workflow makes the commit. Reuses the trace id
+        # from result.json: a fresh one would leave the commit with no correlated
+        # usage, and the receiver would freeze its origin as human-authored.
+        #
+        # continue-on-error, because a reporting gap must not fail a run that has
+        # already produced a reviewed fix.
+        if: steps.apply.outputs.applied == 'true'
+        continue-on-error: true
+        env:
+        run: |
+          set -euo pipefail
+          python -m agentcore.emit_commit \
+            --result /tmp/result.json \
+            --repo "${PRISM_REPO}" \
+            --sha "${{ steps.apply.outputs.sha }}"
+        working-directory: ${{ steps.client.outputs.dir }}
+
+      - name: Open the pull request
+        id: pr
+        if: steps.apply.outputs.applied == 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          set -euo pipefail
+          git push -u origin "${{ steps.apply.outputs.branch }}"
+          VERIFIED=$(jq -r 'if .verified then "The agent ran this repository'"'"'s checks and they passed." else "⚠️ The agent did NOT verify this change. Review with that in mind." end' /tmp/result.json)
+          URL=$(gh pr create \
+            --title "fix: $(jq -r '.issue.title' /tmp/issue.json)" \
+            --body "$(printf 'Closes #%s\n\n%s\n\n%s\n\nGenerated by the PRISM coding agent on AgentCore. Nothing here was merged automatically.\n\n[Run log](%s)\n' \
+                "${{ steps.issue.outputs.number }}" \
+                "$(jq -r '.summary' /tmp/result.json)" \
+                "${VERIFIED}" \
+                "${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}")" \
+            --base "${{ github.event.repository.default_branch }}")
+          echo "url=${URL}" >> "$GITHUB_OUTPUT"
+
+      - name: Report the outcome on the issue
+        if: always()
+        env:
+          GH_TOKEN: ${{ github.token }}
+          OUTCOME: ${{ steps.invoke.outputs.outcome }}
+          PR_URL: ${{ steps.pr.outputs.url }}
+        run: |
+          set -euo pipefail
+          RUN_URL="${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"
+          REASON=$(jq -r '.reason // ""' /tmp/result.json 2>/dev/null || echo "")
+
+          case "${OUTCOME:-failed}" in
+            patched)
+              if [[ -n "${PR_URL}" ]]; then
+                BODY=$(printf '✅ **Fix proposed** — %s\n\nNothing has been merged.\n\n[Run log](%s)' "${PR_URL}" "${RUN_URL}")
+              else
+                BODY=$(printf '⚠️ **The agent produced a patch but it could not be applied or pushed.** See the run log for the reason.\n\n[Run log](%s)' "${RUN_URL}")
+              fi
+              ;;
+            declined)
+              # Declining is frequently the right answer -- for an issue asking the
+              # agent to weaken a test suite, or one whose premise does not hold.
+              # Reporting it as a failure would train people to ignore the signal.
+              BODY=$(printf '🛑 **The agent declined to make a change.**\n\n> %s\n\nThis is often correct: the request may ask for something it should refuse, or rest on a premise that does not hold.\n\n[Run log](%s)' "${REASON}" "${RUN_URL}")
+              ;;
+            *)
+              BODY=$(printf '❌ **The agent could not complete this.**\n\n> %s\n\n[Run log](%s)' "${REASON:-see the run log}" "${RUN_URL}")
+              ;;
+          esac
+
+          gh issue comment "${{ steps.issue.outputs.number }}" --body "${BODY}"
+
+      - name: Upload the transcript
+        if: always()
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: agent-run-issue-${{ steps.issue.outputs.number }}
+          path: |
+            /tmp/invoke.log
+            /tmp/result.json
+            /tmp/fix.patch
+            /tmp/agent-transcript.log
+          retention-days: 14
+          if-no-files-found: ignore