feat: make the right sidebar edit the tasks

Signed-off-by: Simon Emms <simon@simonemms.com>

Author: mrsimonemms

.gitignore

@@ -33,3 +33,4 @@ static/fonts
 
 /workflows
 !/workflows/demo-workflow.yaml
+.claude/

CLAUDE.md

@@ -417,18 +417,26 @@ Key expectations:
 
 Claude should not introduce formatting changes that contradict Prettier output.
 
-**IMPORTANT: Before completing any work, always run `npm run format` and
-`npm run lint` to ensure all files are properly formatted. This is mandatory.**
+**IMPORTANT: Before completing any work, always run the following commands in
+order and ensure they all pass. This is mandatory.**
+
+```sh
+npm run format          # auto-formats all files
+npm run lint            # Prettier check + ESLint + markdownlint
+npm run check           # svelte-check TypeScript type checking
+npm run dev             # verify the app starts without errors
+pre-commit run --all-files  # full pre-commit suite (license, YAML, markdown, ESLint, format)
+```
 
 The `npm run lint` command includes:
 
 - Prettier code formatting check
 - ESLint for JavaScript/TypeScript code
 - Markdown linting (markdownlint-cli2) for all .md files
 
-**IMPORTANT: After fixing format and lint issues, run `npm run dev` to verify
-the application starts without errors. Fix any runtime errors before considering
-the work complete. This is mandatory.**
+The `npm run check` command runs `svelte-kit sync && svelte-check` and must
+report 0 errors before work is considered complete. Fix type errors in source
+and test files; do not suppress them.
 
 ---
 
@@ -439,8 +447,9 @@ the work complete. This is mandatory.**
 - `no-undef` is intentionally disabled
 - Svelte files are type-checked via `typescript-eslint`
 
-**IMPORTANT: Before completing any work, always run `npm run lint` to ensure
-all code passes linting. This is mandatory.**
+**IMPORTANT: Before completing any work, always run `npm run lint` and
+`npm run check` to ensure all code passes linting and type checking. This is
+mandatory.**
 
 Do not:
 

src/lib/export/yaml.ts

@@ -22,6 +22,7 @@
 //   Each SwitchBranch carries an embedded FlowGraph. The exporter "hoists"
 //   those graphs as named `do` tasks at the top level of the document, then
 //   generates `then: <hoisted-name>` references in the switch entries.
+import { isActivityComplexArg } from '$lib/tasks/model';
 import type {
   CallActivityConfig,
   CallGRPCConfig,
@@ -228,17 +229,29 @@ function exportCallActivityConfig(
   c: CallActivityConfig,
 ): Record<string, unknown> {
   const w: Record<string, unknown> = { name: c.name };
-  if (c.arguments !== undefined) w.arguments = c.arguments;
   if (c.taskQueue !== undefined) w.taskQueue = c.taskQueue;
+  if (c.arguments !== undefined) {
+    w.arguments = c.arguments.map((arg) =>
+      isActivityComplexArg(arg) ? arg.value : arg,
+    );
+  }
   return { call: 'activity', with: w };
 }
 
 function exportRunContainerConfig(
   c: RunContainerConfig,
 ): Record<string, unknown> {
   const container: Record<string, unknown> = { image: c.image };
-  if (c.arguments !== undefined) container.arguments = c.arguments;
+  if (c.arguments !== undefined)
+    container.arguments = c.arguments.map((arg) =>
+      isActivityComplexArg(arg) ? arg.value : arg,
+    );
   if (c.environment !== undefined) container.environment = c.environment;
+  if (c.workingDirectory !== undefined)
+    container.workingDirectory = c.workingDirectory;
+  if (c.lifetime !== undefined) container.lifetime = c.lifetime;
+  if (c.await === false) container.await = false;
+  if (c.ports !== undefined) container.ports = c.ports;
   return { run: { container } };
 }
 
@@ -247,39 +260,56 @@ function exportRunScriptConfig(c: RunScriptConfig): Record<string, unknown> {
     language: c.language,
     code: c.code,
   };
-  if (c.arguments !== undefined) script.arguments = c.arguments;
+  if (c.arguments !== undefined)
+    script.arguments = c.arguments.map((arg) =>
+      isActivityComplexArg(arg) ? arg.value : arg,
+    );
   if (c.environment !== undefined) script.environment = c.environment;
   return { run: { script } };
 }
 
 function exportRunShellConfig(c: RunShellConfig): Record<string, unknown> {
   const shell: Record<string, unknown> = { command: c.command };
-  if (c.arguments !== undefined) shell.arguments = c.arguments;
+  if (c.arguments !== undefined)
+    shell.arguments = c.arguments.map((arg) =>
+      isActivityComplexArg(arg) ? arg.value : arg,
+    );
   if (c.environment !== undefined) shell.environment = c.environment;
+  if (c.workingDirectory !== undefined)
+    shell.workingDirectory = c.workingDirectory;
+  if (c.await === false) shell.await = false;
   return { run: { shell } };
 }
 
 function exportRunWorkflowConfig(
   c: RunWorkflowConfig,
 ): Record<string, unknown> {
-  return {
-    run: {
-      workflow: { name: c.name, namespace: c.namespace, version: c.version },
-    },
+  const workflow: Record<string, unknown> = {
+    name: c.name,
+    namespace: c.namespace,
+    version: c.version,
   };
+  if (c.await === false) workflow.await = false;
+  return { run: { workflow } };
 }
 
 function exportWaitConfig(c: WaitConfig): Record<string, unknown> {
   return { wait: c.duration };
 }
 
 function exportRaiseConfig(c: RaiseConfig): Record<string, unknown> {
-  const error: Record<string, unknown> = {
-    type: c.errorType,
-    status: c.errorStatus,
-  };
-  if (c.errorDetail !== undefined) error.detail = c.errorDetail;
-  return { raise: { error } };
+  if (!c.definition) {
+    return { raise: { error: {} } };
+  }
+  const definition: Record<string, unknown> = {};
+  if (c.definition.type !== undefined) definition['type'] = c.definition.type;
+  if (c.definition.title !== undefined)
+    definition['title'] = c.definition.title;
+  if (c.definition.detail !== undefined)
+    definition['detail'] = c.definition.detail;
+  if (c.definition.status !== undefined)
+    definition['status'] = c.definition.status;
+  return { raise: { error: { definition } } };
 }
 
 function exportListenConfig(c: ListenConfig): Record<string, unknown> {