fix: ARM64 runtime platform, individual env vars, and error handler reload

- Set runtimePlatform to ARM64/LINUX on Fargate task definition to match
  the agent Dockerfile's linux/arm64 target platform
- Pass individual env vars (REPO_URL, TASK_DESCRIPTION, etc.) to the
  container instead of a single TASK_PAYLOAD JSON blob, matching what
  the agent entrypoint.py get_config() expects
- Fix HandleError to always reload task from DynamoDB for current status
  instead of using stale state from the SFN input, and handle Error/Cause
  nested under $.error from the catch path

Author: MichaelWalker-git

src/constructs/fargate-agent-cluster.ts

@@ -108,6 +108,10 @@ export class FargateAgentCluster extends Construct {
       cpu: 4096,
       memoryLimitMiB: 16384,
       ephemeralStorageGiB: 100,
+      runtimePlatform: {
+        cpuArchitecture: ecs.CpuArchitecture.ARM64,
+        operatingSystemFamily: ecs.OperatingSystemFamily.LINUX,
+      },
     });
 
     const logGroup = new logs.LogGroup(this, 'LogGroup', {

src/constructs/task-step-function.ts

@@ -107,8 +107,8 @@ export class TaskStepFunction extends Construct {
     const notAdmittedError = new sfn_tasks.LambdaInvoke(this, 'HandleNotAdmitted', {
       lambdaFunction: props.handleErrorFn,
       payload: sfn.TaskInput.fromObject({
-        Error: 'AdmissionDenied',
-        Cause: 'Concurrency limit reached',
+        'Error': 'AdmissionDenied',
+        'Cause': 'Concurrency limit reached',
         'task_id.$': '$.task.task_id',
         'user_id.$': '$.task.user_id',
       }),
@@ -158,7 +158,14 @@ export class TaskStepFunction extends Construct {
       containerOverrides: [{
         containerDefinition: props.containerDefinition,
         environment: [
-          { name: 'TASK_PAYLOAD', value: sfn.JsonPath.stringAt('$.containerOverrides.environment[0].value') },
+          { name: 'REPO_URL', value: sfn.JsonPath.stringAt('$.containerEnv.REPO_URL') },
+          { name: 'TASK_DESCRIPTION', value: sfn.JsonPath.stringAt('$.containerEnv.TASK_DESCRIPTION') },
+          { name: 'ISSUE_NUMBER', value: sfn.JsonPath.stringAt('$.containerEnv.ISSUE_NUMBER') },
+          { name: 'MAX_TURNS', value: sfn.JsonPath.stringAt('$.containerEnv.MAX_TURNS') },
+          { name: 'MAX_BUDGET_USD', value: sfn.JsonPath.stringAt('$.containerEnv.MAX_BUDGET_USD') },
+          { name: 'ANTHROPIC_MODEL', value: sfn.JsonPath.stringAt('$.containerEnv.ANTHROPIC_MODEL') },
+          { name: 'TASK_ID', value: sfn.JsonPath.stringAt('$.containerEnv.TASK_ID') },
+          { name: 'SYSTEM_PROMPT_OVERRIDES', value: sfn.JsonPath.stringAt('$.containerEnv.SYSTEM_PROMPT_OVERRIDES') },
         ],
       }],
       taskTimeout: sfn.Timeout.duration(Duration.hours(8)),

src/handlers/sfn-steps/admission-control.ts

@@ -17,9 +17,9 @@
  *  SOFTWARE.
  */
 
+import { admissionControl } from '../shared/orchestrator';
 import type { BlueprintConfig } from '../shared/repo-config';
 import type { TaskRecord } from '../shared/types';
-import { admissionControl } from '../shared/orchestrator';
 
 interface AdmissionControlInput {
   readonly task: TaskRecord;

src/handlers/sfn-steps/finalize-task.ts

@@ -17,8 +17,8 @@
  *  SOFTWARE.
  */
 
-import type { TaskRecord } from '../shared/types';
 import { finalizeTask } from '../shared/orchestrator';
+import type { TaskRecord } from '../shared/types';
 
 interface FinalizeTaskInput {
   readonly task: TaskRecord;

src/handlers/sfn-steps/handle-error.ts

@@ -17,12 +17,19 @@
  *  SOFTWARE.
  */
 
-import type { TaskRecord } from '../shared/types';
+import type { TaskStatusType } from '../../constructs/task-status';
 import { failTask, loadTask } from '../shared/orchestrator';
+import type { TaskRecord } from '../shared/types';
 
-interface HandleErrorInput {
+interface CatchError {
   readonly Error: string;
   readonly Cause: string;
+}
+
+interface HandleErrorInput {
+  readonly Error?: string;
+  readonly Cause?: string;
+  readonly error?: CatchError;
   readonly task_id?: string;
   readonly user_id?: string;
   readonly task?: TaskRecord;
@@ -34,19 +41,20 @@ interface HandleErrorOutput {
 }
 
 export async function handler(event: HandleErrorInput): Promise<HandleErrorOutput> {
-  const errorMessage = `${event.Error}: ${event.Cause}`;
+  // Error/Cause may be at top level (direct invoke) or nested under $.error (catch path)
+  const errorObj = event.error ?? event;
+  const errorMessage = `${errorObj.Error ?? 'Unknown'}: ${errorObj.Cause ?? 'Unknown'}`;
   const taskId = event.task_id ?? event.task?.task_id;
   const userId = event.user_id ?? event.task?.user_id;
 
   if (taskId && userId) {
-    let currentStatus = event.task?.status;
-    if (!currentStatus) {
-      try {
-        const loaded = await loadTask(taskId);
-        currentStatus = loaded.status;
-      } catch {
-        // Task may not exist or may have been deleted
-      }
+    // Always reload from DynamoDB to get the actual current status
+    let currentStatus: TaskStatusType | undefined;
+    try {
+      const loaded = await loadTask(taskId);
+      currentStatus = loaded.status;
+    } catch {
+      // Task may not exist or may have been deleted
     }
     if (currentStatus) {
       const concurrencyAcquired = currentStatus !== 'SUBMITTED';

src/handlers/sfn-steps/hydrate-context.ts

@@ -17,9 +17,9 @@
  *  SOFTWARE.
  */
 
+import { hydrateAndTransition } from '../shared/orchestrator';
 import type { BlueprintConfig } from '../shared/repo-config';
 import type { TaskRecord } from '../shared/types';
-import { hydrateAndTransition } from '../shared/orchestrator';
 
 interface HydrateContextInput {
   readonly task: TaskRecord;

src/handlers/sfn-steps/load-task.ts

@@ -17,9 +17,9 @@
  *  SOFTWARE.
  */
 
+import { loadBlueprintConfig, loadTask } from '../shared/orchestrator';
 import type { BlueprintConfig } from '../shared/repo-config';
 import type { TaskRecord } from '../shared/types';
-import { loadBlueprintConfig, loadTask } from '../shared/orchestrator';
 
 interface LoadTaskInput {
   readonly task_id: string;

src/handlers/sfn-steps/transition-to-running.ts

@@ -17,25 +17,32 @@
  *  SOFTWARE.
  */
 
-import type { BlueprintConfig } from '../shared/repo-config';
-import type { TaskRecord } from '../shared/types';
 import { TaskStatus } from '../../constructs/task-status';
 import { emitTaskEvent, transitionTask } from '../shared/orchestrator';
+import type { BlueprintConfig } from '../shared/repo-config';
+import type { TaskRecord } from '../shared/types';
 
 interface TransitionToRunningInput {
   readonly task: TaskRecord;
   readonly blueprintConfig: BlueprintConfig;
   readonly payload: Record<string, unknown>;
 }
 
-interface ContainerOverrides {
-  readonly environment: ReadonlyArray<{ readonly name: string; readonly value: string }>;
+interface ContainerEnvVars {
+  readonly REPO_URL: string;
+  readonly TASK_DESCRIPTION: string;
+  readonly ISSUE_NUMBER: string;
+  readonly MAX_TURNS: string;
+  readonly MAX_BUDGET_USD: string;
+  readonly ANTHROPIC_MODEL: string;
+  readonly TASK_ID: string;
+  readonly SYSTEM_PROMPT_OVERRIDES: string;
 }
 
 interface TransitionToRunningOutput {
   readonly task: TaskRecord;
   readonly payload: Record<string, unknown>;
-  readonly containerOverrides: ContainerOverrides;
+  readonly containerEnv: ContainerEnvVars;
 }
 
 export async function handler(event: TransitionToRunningInput): Promise<TransitionToRunningOutput> {
@@ -46,11 +53,17 @@ export async function handler(event: TransitionToRunningInput): Promise<Transiti
   });
   await emitTaskEvent(event.task.task_id, 'task_running', { started_at: startedAt });
 
-  const containerOverrides: ContainerOverrides = {
-    environment: [
-      { name: 'TASK_PAYLOAD', value: JSON.stringify(event.payload) },
-    ],
+  const payload = event.payload;
+  const containerEnv: ContainerEnvVars = {
+    REPO_URL: String(payload.repo_url ?? ''),
+    TASK_DESCRIPTION: String(payload.prompt ?? ''),
+    ISSUE_NUMBER: String(payload.issue_number ?? ''),
+    MAX_TURNS: String(payload.max_turns ?? '100'),
+    MAX_BUDGET_USD: String(payload.max_budget_usd ?? '0'),
+    ANTHROPIC_MODEL: String(payload.model_id ?? ''),
+    TASK_ID: String(event.task.task_id ?? ''),
+    SYSTEM_PROMPT_OVERRIDES: String(payload.system_prompt_overrides ?? ''),
   };
 
-  return { task: event.task, payload: event.payload, containerOverrides };
+  return { task: event.task, payload: event.payload, containerEnv };
 }

test/handlers/sfn-steps/admission-control.test.ts

@@ -17,8 +17,8 @@
  *  SOFTWARE.
  */
 
-import type { TaskRecord } from '../../../src/handlers/shared/types';
 import type { BlueprintConfig } from '../../../src/handlers/shared/repo-config';
+import type { TaskRecord } from '../../../src/handlers/shared/types';
 
 const mockAdmissionControl = jest.fn();
 

test/handlers/sfn-steps/handle-error.test.ts

@@ -43,7 +43,8 @@ const TASK: TaskRecord = {
 
 beforeEach(() => jest.resetAllMocks());
 
-test('fails task when task object is provided', async () => {
+test('fails task when task object is provided (reloads from DDB)', async () => {
+  mockLoadTask.mockResolvedValue({ ...TASK, status: 'RUNNING' });
   mockFailTask.mockResolvedValue(undefined);
 
   const result = await handler({
@@ -52,12 +53,13 @@ test('fails task when task object is provided', async () => {
     task: TASK,
   });
 
+  expect(mockLoadTask).toHaveBeenCalledWith('task-1');
   expect(mockFailTask).toHaveBeenCalledWith(
     'task-1',
-    'HYDRATING',
+    'RUNNING',
     'States.TaskFailed: Container exited with code 1',
     'user-1',
-    true, // concurrencyAcquired: HYDRATING !== SUBMITTED
+    true, // concurrencyAcquired: RUNNING !== SUBMITTED
   );
   expect(result).toEqual({ status: 'failed', error: 'States.TaskFailed: Container exited with code 1' });
 });
@@ -110,6 +112,7 @@ test('handles loadTask failure gracefully', async () => {
 });
 
 test('sets concurrencyAcquired=false when task is SUBMITTED', async () => {
+  mockLoadTask.mockResolvedValue({ ...TASK, status: 'SUBMITTED' });
   mockFailTask.mockResolvedValue(undefined);
 
   await handler({
@@ -118,6 +121,7 @@ test('sets concurrencyAcquired=false when task is SUBMITTED', async () => {
     task: { ...TASK, status: 'SUBMITTED' } as TaskRecord,
   });
 
+  expect(mockLoadTask).toHaveBeenCalledWith('task-1');
   expect(mockFailTask).toHaveBeenCalledWith(
     'task-1',
     'SUBMITTED',
@@ -126,3 +130,22 @@ test('sets concurrencyAcquired=false when task is SUBMITTED', async () => {
     false, // concurrencyAcquired: SUBMITTED === SUBMITTED
   );
 });
+
+test('handles error nested under $.error (catch path)', async () => {
+  mockLoadTask.mockResolvedValue({ ...TASK, status: 'RUNNING' });
+  mockFailTask.mockResolvedValue(undefined);
+
+  const result = await handler({
+    error: { Error: 'States.TaskFailed', Cause: 'Container exited' },
+    task: TASK,
+  } as unknown as Parameters<typeof handler>[0]);
+
+  expect(mockFailTask).toHaveBeenCalledWith(
+    'task-1',
+    'RUNNING',
+    'States.TaskFailed: Container exited',
+    'user-1',
+    true,
+  );
+  expect(result.error).toContain('States.TaskFailed');
+});