K08 — dynamic/static task storage, deletion and lifetime

K08 gives identical worker behavior two storage policies:

• DynamicTask calls xTaskCreate; FreeRTOS allocates TCB and stack from heap_4 and the idle task later reclaims them after self-deletion;
• StaticTask calls xTaskCreateStatic with caller-owned StaticTask_t and StackType_t[] located in .bss; task deletion never transfers ownership of those buffers to the kernel.

Both wrappers remain non-copyable, non-movable and non-virtual. The static storage is a separate StaticTaskStorage<N> object so its TCB/stack are visibly caller supplied and their lifetime is independent from the wrapper's handle.

Measured Hazard3 result

dynamic heap cost          = 0x470 = 1136 bytes
free before idle cleanup   = 0x3b80
free after idle cleanup    = 0x3ff0 (baseline)
static stack words         = 0x100 = 256
static stack bytes         = 0x400 = 1024

The dynamic worker sets completed and clears its wrapper handle before vTaskDelete(nullptr), but its kernel storage is only placed on the termination list at that point. A static verifier first captures the reduced heap, blocks for two ticks to let idle run, then observes full recovery.

Evidence

Stage	Heap relation
baseline	initialized heap_4, no worker kernel object
dynamic start	free decreases by 1136 B
static start	free unchanged from dynamic-start value
static verifier create	free unchanged again
workers completed/self-deleted	dynamic 1136 B still not reclaimed
verifier blocks, idle cleans	free increases by 1136 B to baseline

Addresses prove dynamic TCB/stack lie in ucHeap, while the static TCB and stack equal the caller storage addresses in .bss. Both workers compute 500500.

Build

make check

Expected:

PASS host: dynamic/static policies, stable caller storage and units
PASS ABI: dynamic/static trampolines; caller storage in .bss; no vtable
PASS task01: dynamic/static task storage + idle cleanup

Debug

b task_storage_debug_checkpoint
p g_heap_baseline
p g_heap_after_dynamic_start
p g_heap_after_static_start
p g_heap_before_idle_cleanup
p g_heap_after_idle_cleanup
p/x g_dynamic_tcb
p/x g_dynamic_stack_low
p/x g_static_tcb
p/x g_static_tcb_storage
p/x g_static_stack_low
p/x g_static_stack_storage
p g_static_stack_words
p g_static_stack_bytes
p g_task_storage_pass

Scope boundary

Task deletion does not safely unwind arbitrary application resources on its stack. The workers arrange normal member completion before self-deletion. Static storage must outlive the task and must not be reused merely because a stop was requested; completion/deletion must be established first.