Feature deep dive
A run plan is a named, ordered queue of steps, each targeting an agent slot, executed by Jack's runner without you. Steps for different agents run in parallel lanes. A permission prompt pauses the plan and pings you. A provider usage limit is not a failure: the plan parks itself and resumes exactly when the window resets, surviving app restarts and macOS sleep across a multi-hour window. You queue the night's work; you wake up to a review.
_shared/tasks/.Per plan: ▶ start or resume, ⏸ pause, ⏹ stop, drag to reorder, add, remove or skip a step, and an on-error policy of stop or continue. Steps show a spinner, a status pill and an open-session affordance to jump into the live chat.
The rule is physical, not a policy: an agent slot is one session, so its own steps never overlap. Different agents are independent, so in auto mode they run at once. The one concept you have to learn is the barrier: tick wait for all on a step and nothing after it overtakes it. A barrier is a fence. There is no dependency graph to draw, and that is deliberate; the project has a documented lesson against that direction.
An unattended plan does not get a privileged permission mode to get through the night. When a step raises a permission card, the plan pauses and the card lands where every card lands: the chat, the inbox, the floating HUD, your phone. The step shows needs permission. You answer and resume, or set an always-allow rule for that tool shape and let the next run pass on its own.
When the provider reports a rate limit mid-plan, the step is parked, never marked failed, and the on-error policy is not triggered. Jack reads the reset time from the provider's abstract usage contract and shows the plan as waiting with the time it will resume. A coarse sweep resumes it at the real reset, after an app restart or a laptop sleep. Manual overrides stay available: ▶ runs now, ⏸ cancels the wait, ⏹ stops.
Known limit, stated plainly: a parked turn re-runs its prompt from the top, so tools it had already executed run again.
Every task file under _shared/tasks/ is a card in the sidebar. Add to plan ▸ on a card puts it in a plan; the card then shows in plan «nightly» and disables Play, so the same task never runs twice. Cards carry editable tags with a filter bar, so a workspace with several repos stays sorted.
Plans are the proactive queue. Wake-ups are the reactive loop. Turn on Allow self-scheduling for a slot, typically a transversal coordinator, and it can say "wake me in 15 minutes to re-check open tasks". If idle eviction retired the CLI, the wake-up resumes the session and re-injects the prompt. If nothing needs advancing, the agent does not re-arm and the loop ends. Runaway protection is structural: a five-minute floor, one pending wake-up per slot, and a budget of five consecutive idle re-arms before Jack force-stops the loop and records why. Pending wake-ups show on the workspace timeline, cancellable by you.
The plan pauses and notifies you through the normal channels: the chat, the inbox, the HUD and your phone. An unattended plan never forces a privileged permission mode to get past a prompt. You answer the card and press resume, or set always-allow for that tool shape and let the plan continue on its own next time.
The step is parked, not failed. It never triggers the on-error policy. Jack reads the reset time from the provider's usage contract, shows the plan as waiting, and resumes at the reset even if the app was restarted or the Mac slept in between. Providers without a usage capability fall back to a ten-minute retry window.
In auto mode, steps for different agents run at the same time. Steps for the same agent never overlap, because an agent slot is one session. When you need a real cross-agent dependency, tick wait for all on a step: nothing after that barrier starts until everything before it is done.
Stop means dispatch no more work. It never kills a turn in flight, because killing an agent mid-edit would leave files on disk in an indeterminate state. Continue lets the rest of the plan proceed.
Yes. Each step can override provider, profile, model and effort, and choose whether to reuse the slot's existing session or spawn a clean one.
Not in v1. Plans are authored by you, from the panel composer or with Add to plan on a task card in the sidebar. The card then shows which plan owns it and disables Play, so nothing runs twice.
A wake-up is a single future alarm an agent arms for itself, if you enabled Allow self-scheduling on its slot. At that time Jack reopens the session and re-injects the prompt. To keep looping the agent must re-arm every time. There is a five-minute floor, one pending wake-up per slot, and a budget of five consecutive idle re-arms before Jack force-stops the loop and records why.
Archive them. Archived plans are hidden, kept, losslessly restorable, and can never wake themselves again.