parent task properties: two additional settings when a parent line has a plan

• cascade down:
  • on = sub-tasks get scheduled, parent doesn't
  • off = parent gets scheduled, sub-tasks are just a checklist
• scheduling order (only when cascading):
• parallel — sub-tasks scheduled independently
• sequential — ordered, each waits for the previous; full timeline visible for deadline-driven projects
• sequential one-at-a-time — only the current sub-task is scheduled; next appears after completion.
  • best for open-ended goals decomposed into ordered milestones, not deadline-bound work

parent task duration: not independently set — auto-calculated as sum of sub-task durations when cascading

auto-defer: automatically pushes missed time-bound plans to a later date

• prevents tasks from getting stuck in the past
• downside: silently hides overcommitment
• global default — can disable per task
• recommended alternative: flexible plan + prioritization

buffer: percentage-based padding added after a scheduled task

• absorbs overruns and interruptions
• calculated from task duration (e.g. 20% of 2hrs ≈ 30min open space)
• global default — can override or disable per task

minimum block length (MBL): shortest session SkedPal will schedule for a task

• prevents long tasks from being split into uselessly small fragments
• ignored if task duration is already shorter than MBL
• global default — override per task
• for capping max hours/day, use budgets instead

scheduling type: how a task appears on the calendar

• time block = dedicated calendar event with fixed start/end (for deep work)
• bundle = grouped with other small tasks into a knockout list between fixed events
• defaults to whichever you set globally — override per task via chip
• cascades down

property template: preconfigured bundle of task properties

filter: saved view — narrows Outline by criteria like tags, zones, deadlines, etc.

smart tags: tags that double as property templates

• set via / in task title
• can be just labels, or pre-load: duration, time map(s), scheduling type, plan, zone, priority
• auto-applies stored properties on assignment
• don't cascade — task-specific only

budget: caps scheduled time per day/week for a task or zone

• two levels: zone budget (global) and task budget (local, stacks on top)
• prevents greedy scheduling — stops high-priority tasks from eating all your time
• optional time frame to limit when the cap applies

zone: productivity category for tracking and budgeting time spent (e.g. Focus, Chore, Low Energy)

• a task can only have one zone (unlike time maps)
• no default — unassigned tasks simply have no zone
• cascades down the Outline hierarchy
• used with budgets to cap time per zone (e.g. max 5hrs/week on chores)

priority: relative ranking that determines which tasks get scheduled first

• inherited from parent or falls back to default
• set via chip or triage tool (guided comparison against existing priorities)

if all tasks of a type should be scheduled within specific time window(s), assign the time map to the line defining the type itself

time map: defines preferred scheduling hours for a task

• a task can have multiple time maps
• auto-shown as a chip when a plan is added
• can assign via / key in the task title even without a plan — useful for inheritance (set it on a parent so all sub-tasks pick it up)

duration: time estimate for completing a task

• auto-fills with default duration when a plan is added
• if shorter than scheduling granularity, treated as a small task and bundled with others into one calendar slot
• on a parent with a cascading plan, duration = sum of all sub-task durations (no independent value)

deadline (due date): optional reference date — does NOT drive scheduling (the plan does)

• visible on the Outline line without opening task detail (plan completion date isn't)
• filterable — find all tasks due within a timeframe
• lets you reschedule past the due date while preserving the original deadline (accommodate delayed plans but keep original deadline visible)
• setting a deadline on an unplanned task auto-creates a matching plan, but after that they move independently
• use ONLY for hard external deadlines, not self-imposed ones — use prioritization instead

plan: property that makes a task schedulable

• time-bound = has a completion date
• flexible = no deadline, scheduled by priority
• either can have an optional start date (won't schedule before it)
• a task can hold multiple plans (split work across timeframes)

chip: task property badge * dimmed = global default * arrow = inherited from parent task * normal = directly modified

nested tasks inherit properties from parent tasks.

7 default properties: * duration: how long does this task take? * time map: what time slot should this task be scheduled in? * priority: how important is it that this be task be completed? * scheduling type * time block: dedicated calendar block * bundle: batched into knockout list w/ other small tasks * min. block length: what is the minimum duration for this task? * buffer (set as percentage of estimated duration): relative to the task duration, how much padding should this task have? * auto-defer: if this task is missed, can it be postponed and rescheduled?