razzou-harness 0.4.1 → 0.4.3

package/CHANGELOG.md

@@ -3,6 +3,49 @@
 The notable changes in each release of razzou-harness. Before 1.0, a new minor version
 may change how a project is set up, and its notes say how.
 
+## 0.4.3 (2026-11-08)
+
+**Upgrading from 0.4.2:** install the new version, then rebuild the agents' image with
+`harness doctor --build-images`: its tag follows the harness's version.
+
+- **`harness setup` writes the Terraform scaffold** your bootstrap expects, when you
+  answer its AWS questions, and on any later run: a partial `backend "s3" {}` block in
+  `iac/versions.tf`, `iac/backend-configs/staging.hcl` with the state bucket and the
+  project's key, read from the GitHub variables the bootstrap set, `iac/env/staging.tfvars`
+  with the account, the region and the repository's ids, and the variables and provider
+  they feed. Only missing files are written, a backend block of the project's own is
+  kept, and the files are committed with setup's others. The backend config sets no
+  encryption, so the bucket's default, its KMS key, applies. Until now the doctor
+  required these files and nothing wrote them.
+
+## 0.4.2 (2026-11-08)
+
+**Upgrading from 0.4.1:** upgrade OpenShell to 0.1.7 first, from its Debian package
+(`sudo dpkg -i openshell_0.1.7-1_amd64.deb`); the gateway keeps its providers and
+profiles. Then install the new version, and rebuild the agents' image with `harness
+doctor --build-images`: its tag follows the harness's version. A project's AWS services
+stay as its `harness/config.json` lists them; for every one, set `"services": ["all"]`
+under `aws`.
+
+- **OpenShell 0.1.7.** The harness is pinned to it, and tested with it: the probe passes
+  with every bundle and every AWS service, and the Architect's terminal and the shell
+  in a sandbox work. The doctor's and setup's fix for a stopped gateway now starts its
+  systemd user service: OpenShell's CLI has no command for it.
+- **Every AWS service by default.** `"all"` in `aws.services` is every service the AWS
+  SDK knows, about 420 endpoints in a region with the global ones, each signed with the
+  view role under its own signing name, as OpenShell requires. It is the default, and
+  `harness setup` no longer asks which services the project uses: the view role alone
+  decides what agents read. The table comes from the AWS SDK's own data
+  (`scripts/aws-services.ts` writes it).
+- **AWS reads with `GET` work.** OpenShell's automatic `sigv4` mode signs a request
+  with neither a body nor `x-amz-content-sha256` as `UNSIGNED-PAYLOAD`, which only S3
+  accepts ([NVIDIA/OpenShell#5375](https://github.com/NVIDIA/OpenShell/issues/5375)):
+  every service that reads with `GET`, such as Lambda, API Gateway, EKS, Route 53,
+  CloudFront and Bedrock, answered `SignatureDoesNotMatch` in the sandboxes, and a
+  `terraform plan` there failed on their resources. Every AWS endpoint but S3's is now
+  signed with `sigv4:body`, the hash of the request's body, empty for a `GET`: the AWS
+  CLI's calls to those services and a `terraform plan` reading them work.
+
 ## 0.4.1 (2026-11-08)
 
 **Upgrading a project from 0.4.0:** install the new version, then rebuild the agents'

package/README.md

@@ -106,7 +106,7 @@ without pull requests.
 
 - Linux, Node 24 or later, git, Docker, and `gh` logged in as an admin of your
   project's repository.
-- OpenShell 0.1.2 with a running gateway. The harness is tested with this version only,
+- OpenShell 0.1.7 with a running gateway. The harness is tested with this version only,
   and `harness doctor` refuses others.
 - Claude Code on this machine, with a Claude subscription: its binary goes into the
   sandbox image, and `claude setup-token` gives the agents' token. Access with an API
@@ -140,7 +140,8 @@ gateway key. In order, it logs you in to `gh`; creates
 the repository on GitHub if the project has no remote; creates the App from its
 manifest when this machine has none, and waits for you to install it; writes the
 harness's files; asks the questions and writes `harness/config.json`, with the
-`staging` environment and the variables on GitHub for AWS; commits the files it wrote,
+`staging` environment and the variables on GitHub for AWS, and the Terraform scaffold in
+`iac/` that your bootstrap expects; commits the files it wrote,
 and only those, with your git once you agree, and pushes them when you are on `main`;
 runs `harness doctor` and fixes what it can (starts the OpenShell gateway, builds the
 agents' image, imports the Claude profile and creates the provider with your token,
@@ -433,7 +434,7 @@ through an `Arch:` pull request, or a commit of your own on `main`.
 
 ```json
 {
-  "harnessVersion": "0.4.1",
+  "harnessVersion": "0.4.3",
   "project": { "name": "shop", "repo": "<org>/shop", "bot": "<org>-harness[bot]" },
   "roles": {
     "architect": { "model": "claude-opus-5-5", "effort": "max" },
@@ -554,17 +555,30 @@ and Terraform applies only in CI, after you merge.
    `harness-*` roles and to the gateway user, so your project's own Terraform can't widen
    the agents' access.
 
-**Then, in the project:**
+**Then, in the project** (`harness setup` does steps 1 to 3 when you answer its AWS
+questions):
 1. In `harness/config.json`, add `aws` and `terraform`:
 
    ```json
-   "aws": { "region": "us-east-1", "provider": "aws-view-<org>-shop", "services": ["sts", "s3", "iam", "sqs"] },
+   "aws": { "region": "us-east-1", "provider": "aws-view-<org>-shop", "services": ["all"] },
    "terraform": { "dir": "iac", "backendConfig": "backend-configs/staging.hcl", "varFile": "env/staging.tfvars" }
    ```
 
-   `services` lists the AWS services the project uses: their endpoints become reachable,
-   and signed. Keep the `terraform` paths as they are: the CI workflow uses the same
-   ones. `harness github-setup` then requires `tf-plan` as well.
+   `services` lists the AWS services whose endpoints the sandboxes reach, signed with
+   the view role. `all`, the default, is every service the AWS SDK knows, so the view
+   role alone decides what agents read; a list of names narrows it. Every service but S3
+   is signed with the hash of the request's body, empty for a `GET`: OpenShell's
+   automatic mode signs a bodiless `GET` in a way only S3 accepts
+   ([NVIDIA/OpenShell#5375](https://github.com/NVIDIA/OpenShell/issues/5375)). Keep the `terraform` paths
+   as they are: the CI workflow uses the same ones. `harness github-setup` then requires
+   `tf-plan` as well.
+
+   In `iac/`, the Terraform scaffold: a partial `backend "s3" {}` block, the backend
+   config with the state bucket, the project's key, the region and `use_lockfile = true`,
+   and the variables file. `harness setup` writes whatever of it is missing, from the
+   variables your bootstrap set on GitHub. Its backend config sets no encryption, so the
+   bucket's default, your KMS key, applies: `encrypt = true` without `kms_key_id` would
+   replace it with SSE-S3.
 2. Set the repository variables the workflow reads: `AWS_REGION_STAGING`,
    `AWS_ROLE_PLAN_ARN_STAGING` and `AWS_ROLE_APPLY_ARN_STAGING`.
 3. `harness doctor` creates the OpenShell AWS provider: it asks for the view role's ARN,
@@ -643,8 +657,8 @@ To report a vulnerability, see `SECURITY.md` in the source repository.
 |---|---|
 | `Docker: … permission denied` | Add yourself to the `docker` group, then log in again |
 | `Tailscale: an exit node is active`, or `container network` fails | An exit node can cut the containers' network: turn it off |
-| `OpenShell: … pinned to 0.1.2` | Install OpenShell 0.1.2 |
-| `OpenShell gateway` fails | `openshell gateway start` |
+| `OpenShell: … pinned to 0.1.7` | Install OpenShell 0.1.7, from its Debian package |
+| `OpenShell gateway` fails | `systemctl --user start openshell-gateway`: the gateway is a systemd user service |
 | `image: … has Claude Code X, this machine Y` | `harness doctor --build-images`, after each Claude Code update |
 | `terminals: node-pty is missing` | Install `python3`, `make` and `g++`, then reinstall with `--allow-scripts=node-pty`. `harness attach` works meanwhile. |
 | `Claude provider: … is missing` | `claude setup-token`, then `harness doctor` in a terminal: it asks for the token |

package/dist/design/schemas.js

@@ -165,8 +165,8 @@ export const ConfigSchema = z.object({
         region: z.string().regex(/^[a-z]{2}(-[a-z]+)+-\d$/, 'an AWS region, like us-east-1'),
         /** The OpenShell provider holding the view role, like "aws-view-shop". */
         provider: z.string().min(1),
-        /** The services the project uses: their endpoints are reachable, and signed. */
-        services: z.array(z.string().regex(/^[a-z0-9-]+$/)).default(['sts', 's3', 'iam']),
+        /** The services whose endpoints are reachable, and signed; `all`, the default, is every one, so the view role alone decides. */
+        services: z.array(z.string().regex(/^[a-z0-9-]+$/)).default(['all']),
     })
         .optional(),
     /** Where the project's Terraform lives, and how a plan is made against the real state (§12.4). */

package/dist/sandbox/aws-services.js

@@ -0,0 +1,428 @@
+// Generated by scripts/aws-services.ts from botocore's data (AWS CLI 2.36.48): don't edit it by hand.
+/** Every regional AWS service: its endpoint prefix, its signing name, and its host when not `{service}.{region}.{dnsSuffix}`. */
+export const REGIONAL_SERVICES = [
+    ['a2i-runtime.sagemaker', 'sagemaker'],
+    ['access-analyzer', 'access-analyzer'],
+    ['account-access', 'account-access'],
+    ['acm', 'acm'],
+    ['acm-pca', 'acm-pca'],
+    ['aco-automation', 'aco-automation'],
+    ['admin.wickr', 'wickr'],
+    ['agent-registry', 'agent-registry'],
+    ['agent-registry-control', 'agent-registry'],
+    ['agenttoolkit', 'execute-api'],
+    ['agreement-marketplace', 'aws-marketplace'],
+    ['aidevops', 'aidevops'],
+    ['aiops', 'aiops'],
+    ['airflow', 'airflow'],
+    ['airflow-serverless', 'airflow-serverless'],
+    ['amplify', 'amplify'],
+    ['amplifybackend', 'amplifybackend'],
+    ['amplifyuibuilder', 'amplifyuibuilder'],
+    ['aoss', 'aoss'],
+    ['api.detective', 'detective'],
+    ['api.ecr', 'ecr'],
+    ['api.ecr-public', 'ecr-public'],
+    ['api.iotdeviceadvisor', 'iotdeviceadvisor'],
+    ['api.iotmanagedintegrations', 'iotmanagedintegrations'],
+    ['api.iotwireless', 'iotwireless'],
+    ['api.mediatailor', 'mediatailor'],
+    ['api.pricing', 'pricing'],
+    ['api.sagemaker', 'sagemaker'],
+    ['api.tunneling.iot', 'IoTSecuredTunneling'],
+    ['apigateway', 'apigateway'],
+    ['app-integrations', 'app-integrations'],
+    ['appconfig', 'appconfig'],
+    ['appconfigdata', 'appconfig'],
+    ['appfabric', 'appfabric'],
+    ['appflow', 'appflow'],
+    ['application-autoscaling', 'application-autoscaling'],
+    ['application-cost-profiler', 'application-cost-profiler'],
+    ['application-signals', 'application-signals'],
+    ['applicationinsights', 'applicationinsights'],
+    ['appmesh', 'appmesh'],
+    ['apprunner', 'apprunner'],
+    ['appstream2', 'appstream'],
+    ['appsync', 'appsync'],
+    ['aps', 'aps'],
+    ['arc-region-switch', 'arc-region-switch'],
+    ['arc-zonal-shift', 'arc-zonal-shift'],
+    ['artifact', 'artifact'],
+    ['athena', 'athena'],
+    ['auditmanager', 'auditmanager'],
+    ['autoscaling', 'autoscaling'],
+    ['autoscaling-plans', 'autoscaling-plans'],
+    ['b2bi', 'b2bi'],
+    ['backup', 'backup'],
+    ['backup-gateway', 'backup-gateway'],
+    ['backup-search', 'backup-search'],
+    ['batch', 'batch'],
+    ['bcm-dashboards', 'bcm-dashboards'],
+    ['bcm-data-exports', 'bcm-data-exports'],
+    ['bcm-pricing-calculator', 'bcm-pricing-calculator'],
+    ['bcm-recommended-actions', 'bcm-recommended-actions'],
+    ['bedrock', 'bedrock'],
+    ['bedrock-agent', 'bedrock'],
+    ['bedrock-agent-runtime', 'bedrock'],
+    ['bedrock-agentcore', 'bedrock-agentcore'],
+    ['bedrock-agentcore-control', 'bedrock-agentcore'],
+    ['bedrock-data-automation', 'bedrock'],
+    ['bedrock-data-automation-runtime', 'bedrock'],
+    ['bedrock-runtime', 'bedrock'],
+    ['billing', 'billing'],
+    ['braket', 'braket'],
+    ['cases', 'cases'],
+    ['cassandra', 'cassandra'],
+    ['cassandra-streams', 'cassandra'],
+    ['catalog.marketplace', 'aws-marketplace'],
+    ['chatbot', 'chatbot'],
+    ['cleanrooms', 'cleanrooms'],
+    ['cleanrooms-ml', 'cleanrooms-ml'],
+    ['cloud9', 'cloud9'],
+    ['cloudcontrolapi', 'cloudcontrolapi'],
+    ['clouddirectory', 'clouddirectory'],
+    ['cloudformation', 'cloudformation'],
+    ['cloudfront-keyvaluestore', 'cloudfront-keyvaluestore'],
+    ['cloudhsm', 'cloudhsm'],
+    ['cloudhsmv2', 'cloudhsm'],
+    ['cloudsearch', 'cloudsearch'],
+    ['cloudsearchdomain', 'cloudsearch'],
+    ['cloudtrail', 'cloudtrail'],
+    ['cloudtrail-data', 'cloudtrail-data'],
+    ['codeartifact', 'codeartifact'],
+    ['codebuild', 'codebuild'],
+    ['codecommit', 'codecommit'],
+    ['codeconnections', 'codeconnections'],
+    ['codedeploy', 'codedeploy'],
+    ['codeguru-profiler', 'codeguru-profiler'],
+    ['codeguru-reviewer', 'codeguru-reviewer'],
+    ['codeguru-security', 'codeguru-security'],
+    ['codepipeline', 'codepipeline'],
+    ['codestar-connections', 'codestar-connections'],
+    ['codestar-notifications', 'codestar-notifications'],
+    ['cognito-identity', 'cognito-identity'],
+    ['cognito-idp', 'cognito-idp'],
+    ['cognito-sync', 'cognito-sync'],
+    ['comprehend', 'comprehend'],
+    ['comprehendmedical', 'comprehendmedical'],
+    ['compute-optimizer', 'compute-optimizer'],
+    ['config', 'config'],
+    ['connect', 'connect'],
+    ['connect-campaigns', 'connect-campaigns'],
+    ['contact-lens', 'connect'],
+    ['controlcatalog', 'controlcatalog'],
+    ['controlplane.payment-cryptography', 'payment-cryptography'],
+    ['controltower', 'controltower'],
+    ['cost-optimization-hub', 'cost-optimization-hub'],
+    ['cur', 'cur'],
+    ['data-ats.iot', 'iotdata'],
+    ['data-signer', 'signer'],
+    ['data.iot', 'iotdata'],
+    ['data.jobs.iot', 'iot-jobs-data'],
+    ['data.mediastore', 'mediastore'],
+    ['data.qapps', 'qapps'],
+    ['databrew', 'databrew'],
+    ['dataexchange', 'dataexchange'],
+    ['datapipeline', 'datapipeline'],
+    ['dataplane.payment-cryptography', 'payment-cryptography'],
+    ['datasync', 'datasync'],
+    ['datazone', 'datazone'],
+    ['dax', 'dax'],
+    ['deadline', 'deadline'],
+    ['deployment-marketplace', 'aws-marketplace'],
+    ['devicefarm', 'devicefarm'],
+    ['devops-guru', 'devops-guru'],
+    ['directconnect', 'directconnect'],
+    ['discovery', 'discovery'],
+    ['discovery-marketplace', 'aws-marketplace'],
+    ['dlm', 'dlm'],
+    ['dms', 'dms'],
+    ['docdb', 'docdb'],
+    ['docdb-elastic', 'docdb-elastic'],
+    ['drs', 'drs'],
+    ['ds', 'ds'],
+    ['ds-data', 'ds-data'],
+    ['dsql', 'dsql'],
+    ['dynamodb', 'dynamodb'],
+    ['ebs', 'ebs'],
+    ['ec2', 'ec2'],
+    ['ec2-instance-connect', 'ec2-instance-connect'],
+    ['ecs', 'ecs'],
+    ['edge.sagemaker', 'sagemaker'],
+    ['eks', 'eks'],
+    ['eks-auth', 'eks-auth'],
+    ['elasticache', 'elasticache'],
+    ['elasticbeanstalk', 'elasticbeanstalk'],
+    ['elasticfilesystem', 'elasticfilesystem'],
+    ['elasticloadbalancing', 'elasticloadbalancing'],
+    ['elasticmapreduce', 'elasticmapreduce'],
+    ['elemental-inference', 'elemental-inference'],
+    ['email', 'ses'],
+    ['emr-containers', 'emr-containers'],
+    ['emr-serverless', 'emr-serverless'],
+    ['entitlement.marketplace', 'aws-marketplace'],
+    ['entityresolution', 'entityresolution'],
+    ['es', 'es'],
+    ['events', 'events'],
+    ['evs', 'evs'],
+    ['execute-api', 'execute-api'],
+    ['featurestore-runtime.sagemaker', 'sagemaker'],
+    ['finspace', 'finspace'],
+    ['finspace-api', 'finspace-api'],
+    ['firehose', 'firehose'],
+    ['fis', 'fis'],
+    ['fms', 'fms'],
+    ['forecast', 'forecast'],
+    ['forecastquery', 'forecast'],
+    ['frauddetector', 'frauddetector'],
+    ['freetier', 'freetier'],
+    ['fsx', 'fsx'],
+    ['gamelift', 'gamelift'],
+    ['gameliftstreams', 'gameliftstreams'],
+    ['geo', 'geo'],
+    ['geo-maps', 'geo-maps'],
+    ['geo-places', 'geo-places'],
+    ['geo-routes', 'geo-routes'],
+    ['glacier', 'glacier'],
+    ['globalaccelerator', 'globalaccelerator'],
+    ['glue', 'glue'],
+    ['grafana', 'grafana'],
+    ['greengrass', 'greengrass'],
+    ['groundstation', 'groundstation'],
+    ['guardduty', 'guardduty'],
+    ['health-agent', 'health-agent'],
+    ['healthlake', 'healthlake'],
+    ['iam-toolbox', 'iam'],
+    ['identity-chime', 'chime'],
+    ['identitystore', 'identitystore'],
+    ['imagebuilder', 'imagebuilder'],
+    ['ingest.timestream', 'timestream'],
+    ['inspector', 'inspector'],
+    ['inspector-scan', 'inspector-scan'],
+    ['inspector2', 'inspector2'],
+    ['interconnect', 'interconnect'],
+    ['internetmonitor', 'internetmonitor'],
+    ['invoicing', 'invoicing'],
+    ['iot', 'iot'],
+    ['iotfleetwise', 'iotfleetwise'],
+    ['iotsecuredtunneling', 'iotsecuredtunneling'],
+    ['iotsitewise', 'iotsitewise'],
+    ['iotthingsgraph', 'iotthingsgraph'],
+    ['iottwinmaker', 'iottwinmaker'],
+    ['iotwireless', 'iotwireless'],
+    ['ivs', 'ivs'],
+    ['ivschat', 'ivschat'],
+    ['ivsrealtime', 'ivs'],
+    ['job-runtime.sagemaker', 'sagemaker'],
+    ['kafka', 'kafka'],
+    ['kafkaconnect', 'kafkaconnect'],
+    ['kendra', 'kendra'],
+    ['kendra-ranking', 'kendra-ranking'],
+    ['kinesis', 'kinesis'],
+    ['kinesisanalytics', 'kinesisanalytics'],
+    ['kinesisvideo', 'kinesisvideo'],
+    ['kms', 'kms'],
+    ['lakeformation', 'lakeformation'],
+    ['lambda', 'lambda'],
+    ['launchwizard', 'launchwizard'],
+    ['license-manager', 'license-manager'],
+    ['license-manager-linux-subscriptions', 'license-manager-linux-subscriptions'],
+    ['license-manager-user-subscriptions', 'license-manager-user-subscriptions'],
+    ['lightsail', 'lightsail'],
+    ['logs', 'logs'],
+    ['lookoutequipment', 'lookoutequipment'],
+    ['m2', 'm2'],
+    ['machinelearning', 'machinelearning'],
+    ['macie2', 'macie2'],
+    ['mail-manager', 'ses'],
+    ['managedblockchain', 'managedblockchain'],
+    ['managedblockchain-query', 'managedblockchain-query'],
+    ['marketplacecommerceanalytics', 'marketplacecommerceanalytics'],
+    ['media-pipelines-chime', 'chime'],
+    ['mediaconnect', 'mediaconnect'],
+    ['mediaconvert', 'mediaconvert'],
+    ['medialive', 'medialive'],
+    ['mediapackage', 'mediapackage'],
+    ['mediapackage-vod', 'mediapackage-vod'],
+    ['mediapackagev2', 'mediapackagev2'],
+    ['mediastore', 'mediastore'],
+    ['medical-imaging', 'medical-imaging'],
+    ['meetings-chime', 'chime'],
+    ['memory-db', 'memorydb'],
+    ['messaging-chime', 'chime'],
+    ['metering.marketplace', 'aws-marketplace'],
+    ['metrics.sagemaker', 'sagemaker'],
+    ['mgh', 'mgh'],
+    ['mgn', 'mgn'],
+    ['migrationhub-config', 'mgh'],
+    ['migrationhub-orchestrator', 'migrationhub-orchestrator'],
+    ['migrationhub-strategy', 'migrationhub-strategy'],
+    ['mobileanalytics', 'mobileanalytics'],
+    ['models-v2-lex', 'lex'],
+    ['models.lex', 'lex'],
+    ['monitoring', 'monitoring'],
+    ['mpa', 'mpa'],
+    ['mq', 'mq'],
+    ['neptune', 'neptune'],
+    ['neptune-db', 'neptune-db'],
+    ['neptune-graph', 'neptune-graph'],
+    ['network-firewall', 'network-firewall'],
+    ['networkflowmonitor', 'networkflowmonitor'],
+    ['networkmonitor', 'networkmonitor'],
+    ['notifications', 'notifications'],
+    ['nova-act', 'nova-act'],
+    ['oam', 'oam'],
+    ['observabilityadmin', 'observabilityadmin'],
+    ['odb', 'odb'],
+    ['oidc', 'sso-oauth'],
+    ['omics', 'omics'],
+    ['osis', 'osis'],
+    ['outposts', 'outposts'],
+    ['participant.connect', 'execute-api'],
+    ['partnercentral-account', 'partnercentral-account'],
+    ['partnercentral-benefits', 'partnercentral-benefits'],
+    ['partnercentral-channel', 'partnercentral-channel'],
+    ['partnercentral-prm', 'partnercentral'],
+    ['partnercentral-selling', 'partnercentral-selling'],
+    ['pca-connector-ad', 'pca-connector-ad'],
+    ['pca-connector-scep', 'pca-connector-scep'],
+    ['pcs', 'pcs'],
+    ['personalize', 'personalize'],
+    ['personalize-events', 'personalize'],
+    ['personalize-runtime', 'personalize'],
+    ['pi', 'pi'],
+    ['pinpoint', 'mobiletargeting'],
+    ['pipes', 'pipes'],
+    ['polly', 'polly'],
+    ['portal.sso', 'awsssoportal'],
+    ['pricingplanmanager', 'pricingplanmanager'],
+    ['profile', 'profile'],
+    ['proton', 'proton'],
+    ['qbusiness', 'qbusiness'],
+    ['query.timestream', 'timestream'],
+    ['quicksight', 'quicksight'],
+    ['ram', 'ram'],
+    ['rbin', 'rbin'],
+    ['rds', 'rds'],
+    ['rds-data', 'rds-data'],
+    ['redshift', 'redshift'],
+    ['redshift-data', 'redshift-data'],
+    ['redshift-serverless', 'redshift-serverless'],
+    ['refactor-spaces', 'refactor-spaces'],
+    ['rekognition', 'rekognition'],
+    ['reporting-marketplace', 'aws-marketplace'],
+    ['repostspace', 'repostspace'],
+    ['resiliencehub', 'resiliencehub'],
+    ['resource-explorer-2', 'resource-explorer-2'],
+    ['resource-groups', 'resource-groups'],
+    ['rolesanywhere', 'rolesanywhere'],
+    ['route53-recovery-cluster', 'route53-recovery-cluster'],
+    ['route53-recovery-control-config', 'route53-recovery-control-config'],
+    ['route53-recovery-readiness', 'route53-recovery-readiness'],
+    ['route53domains', 'route53domains'],
+    ['route53globalresolver', 'route53globalresolver'],
+    ['route53profiles', 'route53profiles'],
+    ['route53resolver', 'route53resolver'],
+    ['rtbfabric', 'rtbfabric'],
+    ['rum', 'rum'],
+    ['runtime-v2-lex', 'lex'],
+    ['runtime.lex', 'lex'],
+    ['runtime.sagemaker', 'sagemaker'],
+    ['s3', 's3'],
+    ['s3-control', 's3'],
+    ['s3-outposts', 's3-outposts'],
+    ['s3files', 's3files'],
+    ['s3tables', 's3tables'],
+    ['s3vectors', 's3vectors'],
+    ['sagemaker-geospatial', 'sagemaker-geospatial'],
+    ['scheduler', 'scheduler'],
+    ['schemas', 'schemas'],
+    ['scn', 'scn'],
+    ['sdb', 'sdb'],
+    ['secretsmanager', 'secretsmanager'],
+    ['security-ir', 'security-ir'],
+    ['securityagent', 'securityagent'],
+    ['securityhub', 'securityhub'],
+    ['securitylake', 'securitylake'],
+    ['serverlessrepo', 'serverlessrepo'],
+    ['servicecatalog', 'servicecatalog'],
+    ['servicecatalog-appregistry', 'servicecatalog'],
+    ['servicediscovery', 'servicediscovery'],
+    ['servicequotas', 'servicequotas'],
+    ['signer', 'signer'],
+    ['signin', 'signin'],
+    ['sms-voice', 'sms-voice'],
+    ['sms-voice.pinpoint', 'sms-voice'],
+    ['snow-device-management', 'snow-device-management'],
+    ['snowball', 'snowball'],
+    ['sns', 'sns'],
+    ['social-messaging', 'social-messaging'],
+    ['sqs', 'sqs'],
+    ['ssm', 'ssm'],
+    ['ssm-contacts', 'ssm-contacts'],
+    ['ssm-guiconnect', 'ssm-guiconnect'],
+    ['ssm-incidents', 'ssm-incidents'],
+    ['ssm-quicksetup', 'ssm-quicksetup'],
+    ['ssm-sap', 'ssm-sap'],
+    ['sso', 'sso'],
+    ['states', 'states'],
+    ['storagegateway', 'storagegateway'],
+    ['streams.dynamodb', 'dynamodb'],
+    ['sts', 'sts'],
+    ['support', 'support'],
+    ['supportapp', 'supportapp'],
+    ['supportauthz', 'supportauthz'],
+    ['sustainability', 'sustainability'],
+    ['swf', 'swf'],
+    ['synthetics', 'synthetics'],
+    ['tagging', 'tagging'],
+    ['textract', 'textract'],
+    ['thinclient', 'thinclient'],
+    ['timestream-influxdb', 'timestream-influxdb'],
+    ['tnb', 'tnb'],
+    ['transcribe', 'transcribe'],
+    ['transcribestreaming', 'transcribestreaming'],
+    ['transfer', 'transfer'],
+    ['translate', 'translate'],
+    ['trustedadvisor', 'trustedadvisor'],
+    ['uxc', 'uxc'],
+    ['verifiedpermissions', 'verifiedpermissions'],
+    ['voice-chime', 'chime'],
+    ['voiceid', 'voiceid'],
+    ['vpc-lattice', 'vpc-lattice'],
+    ['waf-regional', 'waf-regional'],
+    ['wafv2', 'wafv2'],
+    ['wellarchitected', 'wellarchitected'],
+    ['wisdom', 'wisdom'],
+    ['workdocs', 'workdocs'],
+    ['workmail', 'workmail'],
+    ['workmailmessageflow', 'workmailmessageflow'],
+    ['workspaces', 'workspaces'],
+    ['workspaces-instances', 'workspaces-instances'],
+    ['workspaces-web', 'workspaces-web'],
+    ['xray', 'xray'],
+];
+/** Every global AWS endpoint: the service, its host, its signing name, and the region it signs for. */
+export const GLOBAL_SERVICES = [
+    ['account', 'account.us-east-1.amazonaws.com', 'account', 'us-east-1'],
+    ['billingconductor', 'billingconductor.us-east-1.amazonaws.com', 'billingconductor', 'us-east-1'],
+    ['budgets', 'budgets.amazonaws.com', 'budgets', 'us-east-1'],
+    ['ce', 'ce.us-east-1.amazonaws.com', 'ce', 'us-east-1'],
+    ['chime', 'chime.us-east-1.amazonaws.com', 'chime', 'us-east-1'],
+    ['cloudfront', 'cloudfront.amazonaws.com', 'cloudfront', 'us-east-1'],
+    ['codecatalyst', 'codecatalyst.global.api.aws', 'codecatalyst', 'us-east-1'],
+    ['health', 'global.health.amazonaws.com', 'health', 'us-east-1'],
+    ['iam', 'iam.amazonaws.com', 'iam', 'us-east-1'],
+    ['importexport', 'importexport.amazonaws.com', 'IngestionService', 'us-east-1'],
+    ['networkmanager', 'networkmanager.us-west-2.amazonaws.com', 'networkmanager', 'us-west-2'],
+    ['notifications-contacts', 'notifications-contacts.us-east-1.api.aws', 'notifications-contacts', 'us-east-1'],
+    ['organizations', 'organizations.us-east-1.amazonaws.com', 'organizations', 'us-east-1'],
+    ['route53', 'route53.amazonaws.com', 'route53', 'us-east-1'],
+    ['s3', 's3.amazonaws.com', 's3', 'us-east-1'],
+    ['savingsplans', 'savingsplans.amazonaws.com', 'savingsplans', 'us-east-1'],
+    ['shield', 'shield.us-east-1.amazonaws.com', 'shield', 'us-east-1'],
+    ['sts', 'sts.amazonaws.com', 'sts', 'us-east-1'],
+    ['support', 'support.us-east-1.amazonaws.com', 'support', 'us-east-1'],
+    ['tax', 'tax.us-east-1.amazonaws.com', 'tax', 'us-east-1'],
+    ['waf', 'waf.amazonaws.com', 'waf', 'us-east-1'],
+];

package/dist/sandbox/policy.js

@@ -1,4 +1,5 @@
 import { BUNDLES, bundleNames, checkHost } from './allowlist.js';
+import { GLOBAL_SERVICES, REGIONAL_SERVICES } from './aws-services.js';
 /** Services whose endpoints don't follow `<service>.<region>.amazonaws.com`. Global ones sign for us-east-1. */
 const AWS_SERVICES = {
     iam: { hosts: () => ['iam.amazonaws.com'], signing: 'iam', global: true },
@@ -8,26 +9,48 @@ const AWS_SERVICES = {
     cloudfront: { hosts: () => ['cloudfront.amazonaws.com'], signing: 'cloudfront', global: true },
     route53: { hosts: () => ['route53.amazonaws.com'], signing: 'route53', global: true },
 };
+/** In `aws.services`, every AWS service: the view role alone then decides what agents read. */
+export const ALL_SERVICES = 'all';
 /**
  * One signed endpoint per host. `access: full`, because most AWS APIs are POSTs: the
- * role itself is what allows only reads (spike 2).
+ * role itself is what allows only reads (spike 2). OpenShell signs only for endpoints
+ * named with their service, with no rule for every AWS host, so `all` names every one
+ * the AWS SDK knows (aws-services.ts), with the hosts that carry a bucket's or an
+ * account's name in front.
+ *
+ * Every service but S3 is signed with `sigv4:body`: the hash of the request's body, an
+ * empty one for a GET. OpenShell's automatic `sigv4` signs a request with neither a body
+ * nor `x-amz-content-sha256` as UNSIGNED-PAYLOAD, which only S3 accepts, so every other
+ * service's GET failed (NVIDIA/OpenShell#5375). S3 keeps it: its SDKs say how to sign.
  */
 function awsEndpoints(aws) {
-    return aws.services.flatMap((service) => {
+    const signed = (host, service, region) => ({
+        host,
+        port: 443,
+        protocol: 'rest',
+        enforcement: 'enforce',
+        access: 'full',
+        credential_binding: { provider: aws.provider },
+        credential_signing: service === 's3' ? 'sigv4' : 'sigv4:body',
+        signing_service: service,
+        ...(region ? { signing_region: region } : {}),
+    });
+    const named = aws.services.filter((service) => service !== ALL_SERVICES).flatMap((service) => {
         const known = AWS_SERVICES[service];
         const hosts = known ? known.hosts(aws.region) : [`${service}.${aws.region}.amazonaws.com`];
-        return hosts.map((host) => ({
-            host,
-            port: 443,
-            protocol: 'rest',
-            enforcement: 'enforce',
-            access: 'full',
-            credential_binding: { provider: aws.provider },
-            credential_signing: 'sigv4',
-            signing_service: known?.signing ?? service,
-            ...(known?.global ? { signing_region: 'us-east-1' } : {}),
-        }));
+        return hosts.map((host) => signed(host, known?.signing ?? service, known?.global ? 'us-east-1' : undefined));
     });
+    const all = aws.services.includes(ALL_SERVICES)
+        ? [
+            ...REGIONAL_SERVICES.map(([prefix, service, template]) => signed((template ?? '{service}.{region}.{dnsSuffix}').replace('{service}', prefix).replace('{region}', aws.region).replace('{dnsSuffix}', 'amazonaws.com'), service)),
+            signed(`*.s3.${aws.region}.amazonaws.com`, 's3'),
+            signed(`*.s3-control.${aws.region}.amazonaws.com`, 's3'),
+            ...GLOBAL_SERVICES.map(([, host, service, region]) => signed(host, service, region)),
+        ]
+        : [];
+    // One rule per host, a named service's first.
+    const endpoints = [...named, ...all];
+    return endpoints.filter((endpoint, i) => endpoints.findIndex((other) => other.host === endpoint.host) === i);
 }
 /**
  * Programs whose connections the rules cover. A rule also applies to the processes a

package/dist/setup/doctor.js

@@ -16,7 +16,7 @@ import { run } from '../util.js';
 import { buildCache, removeOldAgentImages } from './images.js';
 import { probe, stateLocation } from './probe.js';
 /** The OpenShell release the harness is built and probed against (§17.4). */
-export const OPENSHELL_VERSION = '0.1.2';
+export const OPENSHELL_VERSION = '0.1.7';
 /** OpenShell's AWS provider profile, at that release. */
 const AWS_PROFILE_URL = `https://raw.githubusercontent.com/NVIDIA/OpenShell/v${OPENSHELL_VERSION}/providers/aws.yaml`;
 /**
@@ -75,7 +75,7 @@ async function machine(options, image, report) {
     else
         report(found === OPENSHELL_VERSION ? ok('OpenShell', found) : fail('OpenShell', `${found}, but the harness is pinned to ${OPENSHELL_VERSION}`, `install OpenShell ${OPENSHELL_VERSION}`));
     const status = await run('openshell', ['status']).catch(() => undefined);
-    report(/Status:\s*Connected/.test(status?.stdout ?? '') ? ok('OpenShell gateway', 'connected') : fail('OpenShell gateway', firstLine(status?.stdout || status?.stderr) || 'not running', 'start the gateway: `openshell gateway start`'));
+    report(/Status:\s*Connected/.test(status?.stdout ?? '') ? ok('OpenShell gateway', 'connected') : fail('OpenShell gateway', firstLine(status?.stdout || status?.stderr) || 'not running', 'start the gateway, a systemd user service: `systemctl --user start openshell-gateway`'));
     const host = await run('claude', ['--version']).catch(() => undefined);
     const hostClaude = /^(\S+)/.exec(host?.stdout ?? '')?.[1];
     report(hostClaude ? ok('Claude Code', hostClaude) : fail('Claude Code', 'not found', 'install Claude Code: the agents\' image takes it from this machine'));
@@ -218,7 +218,7 @@ async function project(options, config, report) {
     if (config.terraform) {
         const tf = config.terraform;
         for (const file of [tf.backendConfig, tf.varFile]) {
-            report(existsSync(join(options.projectDir, tf.dir, file)) ? ok('Terraform', `${tf.dir}/${file}`) : fail('Terraform', `${tf.dir}/${file} is missing`, 'see harness/config.json under terraform'));
+            report(existsSync(join(options.projectDir, tf.dir, file)) ? ok('Terraform', `${tf.dir}/${file}`) : fail('Terraform', `${tf.dir}/${file} is missing`, '`harness setup` writes the missing Terraform scaffold, or see the README\'s AWS section'));
         }
     }
 }

package/dist/setup/setup.js

@@ -7,6 +7,7 @@ import { applyRepositoryRules, checkApp, createApp, installCi } from '../github/
 import { run, sha256 } from '../util.js';
 import { doctor, granted } from './doctor.js';
 import { appBot, githubRepo, init } from './init.js';
+import { writeTerraformScaffold } from './terraform.js';
 export function fixFor(check) {
     if (check.status === 'ok' || check.status === 'skip')
         return undefined;
@@ -214,24 +215,46 @@ async function askSettings(options) {
     const written = [];
     let changed = false;
     let viewRole;
+    let account;
     if (!config.aws && /^y/i.test(await ask('Does this project deploy to AWS with Terraform? [y/N] '))) {
         say('The roles come from your bootstrap (see the README\'s AWS section); the key is asked for later, at a hidden prompt.');
         const region = (await ask('AWS region (like eu-west-1): ')).trim();
         const view = (await ask("The agents' view role ARN (arn:aws:iam::<account>:role/harness-<project>-view): ")).trim();
         const plan = (await ask('The CI plan role ARN: ')).trim();
         const apply = (await ask('The CI apply role ARN: ')).trim();
-        const services = (await ask('The AWS services the project uses, comma-separated (sts, s3, iam, ...): ')).split(/[,\s]+/).filter(Boolean);
         if (!region || !VIEW_ROLE.test(view) || !ROLE.test(plan) || !ROLE.test(apply)) {
             say('AWS skipped: a value is missing or malformed. Add `aws` and `terraform` to harness/config.json by hand, or run `harness setup` again.');
         }
         else {
-            config.aws = { region, provider: awsProviderName(projectDir, config.project?.repo), services: [...new Set(['sts', ...services])] };
+            config.aws = { region, provider: awsProviderName(projectDir, config.project?.repo), services: ['all'] };
             config.terraform = { dir: 'iac', backendConfig: 'backend-configs/staging.hcl', varFile: 'env/staging.tfvars' };
             changed = true;
             viewRole = view;
             const repo = config.project?.repo;
             if (repo)
                 await configureGitHubForAws(options, repo, { region, plan, apply });
+            account = /^arn:aws:iam::(\d{12}):/.exec(view)[1];
+        }
+    }
+    // The Terraform scaffold the bootstrap expects, which the doctor checks: whatever of it is
+    // missing, on this run or a later one. A later run reads the account from the plan role
+    // this one stored on GitHub.
+    if (config.aws?.region && config.terraform) {
+        const repo = config.project?.repo;
+        account ??= /^arn:aws:iam::(\d{12}):/.exec((await githubVariable(repo, 'AWS_ROLE_PLAN_ARN_STAGING')) ?? '')?.[1];
+        if (account) {
+            const layout = { dir: 'iac', backendConfig: 'backend-configs/staging.hcl', varFile: 'env/staging.tfvars', ...config.terraform };
+            // As the schema reads it: `iac`, `./iac` and `iac/` are one folder. Slashes are trimmed by hand: a regex would take quadratic time on a long run of them.
+            let dir = layout.dir;
+            while (dir.startsWith('./') || dir.startsWith('/'))
+                dir = dir.slice(dir.startsWith('./') ? 2 : 1);
+            while (dir.endsWith('/'))
+                dir = dir.slice(0, -1);
+            layout.dir = dir || 'iac';
+            const scaffold = writeTerraformScaffold(projectDir, layout, await terraformFacts(repo, String(config.project?.name ?? 'project'), String(config.aws.region), account));
+            if (scaffold.length > 0)
+                say(`Terraform: wrote ${scaffold.join(', ')}.`);
+            written.push(...scaffold);
         }
     }
     if (changed) {
@@ -255,6 +278,30 @@ async function askSettings(options) {
     }
     return { written, ...(viewRole ? { viewRole } : {}) };
 }
+/**
+ * Where the project's state lives, and its repository's numeric ids: read from GitHub, where
+ * the bootstrap's configure-github.sh set TF_STATE_BUCKET_STAGING and TF_STATE_KEY_STAGING,
+ * or else by the bootstrap's naming, `tf-state-staging-<account>` and
+ * `staging/<repository>/terraform.tfstate`.
+ */
+async function terraformFacts(repo, name, region, account) {
+    const bucket = await githubVariable(repo, 'TF_STATE_BUCKET_STAGING');
+    const key = await githubVariable(repo, 'TF_STATE_KEY_STAGING');
+    const ids = (await ghApi(repo, `repos/${repo}`, '"\\(.owner.id) \\(.id)"'))?.split(' ');
+    return {
+        region,
+        account,
+        bucket: bucket ?? `tf-state-staging-${account}`,
+        key: key ?? `staging/${repo ? repo.split('/')[1] : name}/terraform.tfstate`,
+        ...(repo && ids?.length === 2 ? { github: { repo, ownerId: ids[0], repoId: ids[1] } } : {}),
+    };
+}
+/** What the owner's gh reads at `path`, through `jq`; undefined without a repository, or on any failure. */
+async function ghApi(repo, path, jq) {
+    const result = repo ? await run('gh', ['api', path, '--jq', jq]).catch(() => undefined) : undefined;
+    return result?.code === 0 && result.stdout.trim() ? result.stdout.trim() : undefined;
+}
+const githubVariable = (repo, name) => ghApi(repo, `repos/${repo}/actions/variables/${name}`, '.value');
 /** The staging environment, restricted to main, and the variables the workflow reads, with the owner's gh. */
 async function configureGitHubForAws(options, repo, aws) {
     const gh = async (args, body) => {
@@ -334,11 +381,12 @@ async function applyFix(options, config, fix, sleep) {
     const repo = config.project.repo;
     switch (fix.kind) {
         case 'start-gateway': {
-            const started = await run('openshell', ['gateway', 'start']).catch(() => undefined);
+            // OpenShell's Debian package runs the gateway as a systemd user service; its CLI has no command to start it.
+            const started = await run('systemctl', ['--user', 'start', 'openshell-gateway']).catch(() => undefined);
             if (started?.code === 0)
                 say('OpenShell: gateway started.');
             else
-                say(`OpenShell: the gateway did not start: ${(started?.stderr || started?.stdout || 'openshell is missing').trim()}`);
+                say(`OpenShell: the gateway did not start: ${(started?.stderr || started?.stdout || 'systemctl is missing').trim()}`);
             return started?.code === 0;
         }
         case 'create-app':

package/dist/setup/terraform.js

@@ -0,0 +1,86 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+/**
+ * Writes the Terraform scaffold the bootstrap expects in the layout's folder: a partial
+ * `backend "s3"` block in `versions.tf`, the backend config and the variables file, and the
+ * variables and provider those values feed. Only what is missing is written: an existing
+ * file, or a backend block in any of the folder's `.tf` files, is the project's own. The
+ * backend config sets no encryption, so the bucket's default, the bootstrap's KMS key,
+ * applies: `encrypt = true` without `kms_key_id` would replace it with SSE-S3. Every file
+ * is as `terraform fmt` writes it, which CI checks. Returns the paths written, from the
+ * project's root.
+ */
+export function writeTerraformScaffold(projectDir, layout, values) {
+    const { dir } = layout;
+    const written = [];
+    const write = (path, content) => {
+        const file = join(projectDir, dir, path);
+        if (existsSync(file))
+            return false;
+        mkdirSync(dirname(file), { recursive: true });
+        writeFileSync(file, content);
+        written.push(`${dir}/${path}`);
+        return true;
+    };
+    const folder = join(projectDir, dir);
+    const hasBackend = existsSync(folder)
+        && readdirSync(folder).filter((f) => f.endsWith('.tf')).some((f) => /^\s*backend\s+"/m.test(readFileSync(join(folder, f), 'utf8')));
+    if (!hasBackend) {
+        write('versions.tf', [
+            'terraform {',
+            '  required_version = ">= 1.10"',
+            '',
+            '  required_providers {',
+            '    aws = {',
+            '      source  = "hashicorp/aws"',
+            '      version = "~> 6.65"',
+            '    }',
+            '  }',
+            '',
+            `  # Partial configuration: the values are in ${layout.backendConfig}, for`,
+            `  #   terraform init -backend-config=${layout.backendConfig}`,
+            '  backend "s3" {}',
+            '}',
+            '',
+        ].join('\n'));
+    }
+    write(layout.backendConfig, [
+        ...assignments([['bucket', values.bucket], ['key', values.key], ['region', values.region]]),
+        '',
+        "# No encrypt or kms_key_id: the bucket's default encryption, its KMS key, applies.",
+        '# encrypt = true without kms_key_id would replace it with SSE-S3.',
+        'use_lockfile = true',
+        '',
+    ].join('\n'));
+    const github = values.github;
+    const variables = [
+        ['env', 'staging', 'The environment.'],
+        ['aws_account_id', values.account, 'The AWS account the environment is in.'],
+        ['aws_region', values.region, 'The AWS region the environment is in.'],
+        ...(github ? [
+            ['github_repo', github.repo, 'The GitHub repository, as owner/name.'],
+            ['github_owner_id', github.ownerId, "The repository owner's numeric id, which OIDC trust policies pin."],
+            ['github_repo_id', github.repoId, "The repository's numeric id, which OIDC trust policies pin."],
+        ] : []),
+    ];
+    const tfvars = [
+        ...assignments(variables.slice(0, 3).map(([name, value]) => [name, value])),
+        ...(github ? ['', ...assignments(variables.slice(3).map(([name, value]) => [name, value]))] : []),
+        '',
+    ].join('\n');
+    // The variables follow the values: a tfvars file of the project's own sets its own.
+    if (write(layout.varFile, tfvars)) {
+        write('variables.tf', variables.map(([name, , description]) => [
+            `variable "${name}" {`,
+            ...assignments([['description', description], ['type', 'string']], ['type']).map((line) => `  ${line}`),
+            '}',
+        ].join('\n')).join('\n\n') + '\n');
+        write('providers.tf', ['provider "aws" {', '  region = var.aws_region', '}', ''].join('\n'));
+    }
+    return written;
+}
+/** `name = "value"` lines with their equals signs aligned, as `terraform fmt` aligns them; `bare` names take an expression, unquoted. */
+function assignments(pairs, bare = []) {
+    const width = Math.max(...pairs.map(([name]) => name.length));
+    return pairs.map(([name, value]) => `${name.padEnd(width)} = ${bare.includes(name) ? value : JSON.stringify(value)}`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "razzou-harness",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Your AI dev team, with you in charge: sandboxed Claude Code agents design, build and review your project, and you merge.",
   "license": "MIT",
   "author": "razzou",