Goal Activating

Transform a defined goal into an active execution thread.

Responsibility

Create an execution thread for a goal using the causal flow pattern. Link the thread to the goal and route to the appropriate agent.

Quick Start

• Read goal from strategy/goals/active/{goal-id}.md

• Determine thread location based on goal category

• Create thread directory with causal flow structure

• Initialize 1-input.md with goal context

• Update goal file with thread link

• Route to appropriate agent

Causal Flow Structure

Every execution thread follows this structure:

threads/{domain}/{thread-name}/ └── 1-input.md # Goal context, constraints, success criteria # Stages 2-6 created by sys-executing-threads when agents write output

Thread Location Mapping

Goal Category Thread Domain Agent

revenue revops rop-allocator

activity marketing or sales mkt-campaign-manager or sls-outbound-manager

content marketing mkt-content-manager

efficiency revops rop-evaluator

retention customer cst-lifecycle-manager

Detailed Routing

Revenue Goals: ├── Pipeline target → threads/revops/ → rop-allocator ├── Bookings target → threads/sales/ → sls-strategist └── Expansion target → threads/customer/ → cst-growth-manager

Activity Goals: ├── Meeting target → threads/sales/ → sls-outbound-manager ├── Outreach target → threads/sales/ → sls-outbound-manager ├── MQL target → threads/marketing/ → mkt-inbound-manager └── Demo target → threads/sales/ → sls-outbound-manager

Content Goals: ├── Production target → threads/marketing/ → mkt-content-manager ├── Traffic target → threads/marketing/ → mkt-campaign-manager └── SEO target → threads/marketing/ → mkt-content-manager

Efficiency Goals: ├── Conversion rate → threads/revops/ → rop-calibrator ├── Cycle time → threads/sales/ → sls-strategist └── CAC optimization → threads/revops/ → rop-evaluator

Retention Goals: ├── Churn reduction → threads/customer/ → cst-lifecycle-manager ├── NRR target → threads/customer/ → cst-growth-manager └── Renewal rate → threads/customer/ → cst-lifecycle-manager

Thread Naming

Format: {goal-metric}_{period-short}

Examples:

• pipeline_2026q1

• meetings_2026m01

• content-production_2026q1

• churn-reduction_2026q1

Output Structure

Thread Directory

threads/{domain}/{thread-name}/ └── 1-input.md # Only file created by this skill # 2-6 created by sys-executing-threads

1-input.md Format

thread_id: {domain}_{thread-name} goal_id: {linked goal id} created: {YYYY-MM-DD} owner: {agent name} status: active

{Goal Name} Execution

Goal Link

Goal: strategy/goals/active/{goal-id}.md Target: {target_value} {unit} Deadline: {period_end} Gap: {current gap to close}

Context

Current State

{baseline_value} {unit} as of {baseline_date}

Constraints

Assumptions

Success Criteria

Milestones

Dependencies

Requires

• {upstream goals or resources}

Enables

• {downstream goals}

Risk Factors

• {risk_1}
• {risk_2}

Routing

Assigned Agent: {agent-name} Reason: {category-based routing logic}

Stages 2-6

Templates for stages 2-6 are defined in sys-executing-threads . This skill does NOT create them. Agents produce output, then call sys-executing-threads to write the stage files.

Process

Step 1: Read Goal

Read: strategy/goals/active/{goal-id}.md Extract:

• goal_id
• name
• category
• target_value, target_unit
• period_start, period_end
• baseline_value
• constraints
• assumptions
• risk_factors
• milestones

Step 2: Determine Thread Location

1. Map category to domain
2. Check if parent goal has thread (coordinate)
3. Generate thread name from metric + period
4. Full path: threads/{domain}/{thread-name}/

Step 3: Create Thread Directory

1. Create directory if not exists
2. Create 1-input.md (populated with goal context)
   • Stages 2-6 are NOT created here
   • They are created by sys-executing-threads when agents write output

Step 4: Populate 1-input.md

1. Copy goal context into 1-input.md frontmatter
2. Format success criteria from goal targets
3. Include constraints and assumptions
4. List milestones as checkpoints
5. Note dependencies and risks
6. Assign agent based on routing

Step 5: Update Goal File

Add thread link to goal frontmatter: thread: threads/{domain}/{thread-name}

Update status: status: activated

Step 6: Route to Agent

Return activation context: thread_path: threads/{domain}/{thread-name} assigned_agent: {agent-name} goal_id: {goal-id} priority: {from goal urgency}

Batch Activation

For decomposed goal hierarchies:

1. Identify leaf goals (no children)
2. Sort by dependency order
3. Activate each leaf goal
4. Parent goals activate when children complete

Activation Priority

Condition Priority

Deadline < 7 days critical

Deadline < 14 days high

Deadline < 30 days medium

Deadline > 30 days low

Blocking other goals +1 level

Workflow

1. RECEIVE goal_id to activate

2. READ goal file └── Parse frontmatter and body └── Extract all goal attributes

3. CHECK activation readiness └── Goal status must be "active" └── Goal must not already have thread └── Dependencies should be met (or flag)

4. DETERMINE thread location └── Map category → domain └── Generate thread name └── Create full path

5. CREATE thread structure └── Make directory └── Write 1-input.md with goal context └── Stages 2-6 created later by sys-executing-threads

6. UPDATE goal file └── Add thread link └── Update status to "activated"

7. RETURN activation context └── thread_path └── assigned_agent └── priority

Integration

Upstream

• sys-defining-goals : Provides goal to activate

• sys-decomposing-goals : Provides leaf goals to activate

Downstream

• Assigned agent receives thread for execution

• sys-tracking-goals : Monitors thread progress against goal

With Agents

The assigned agent:

• Reads 1-input.md

• Fills 2-hypothesis.md with approach

• Derives 3-implication.md

• Makes 4-decision.md

• Executes 5-actions.md

• Records 6-learning.md

Agents write to stage files via sys-executing-threads skill, which handles frontmatter updates and completion tracking.

Boundaries

This skill provides:

• Thread creation for goals

• Causal flow structure initialization

• Goal-thread linking

• Agent routing

This skill does NOT:

• Define goals (use sys-defining-goals )

• Decompose goals (use sys-decomposing-goals )

• Execute the work (agents do)

• Track progress (use sys-tracking-goals )

Example

Input

Goal: goal_activity_meetings_2026q1

• Category: activity

• Target: 100 meetings

• Period: Q1 2026

• Baseline: 0 (new quarter)

Process

• Read goal file

• Map: activity → sales domain

• Route: meetings → sls-outbound-manager

• Thread path: threads/sales/meetings_2026q1/

• Create directory and files

• Populate 1-input.md with goal context

• Update goal: thread: threads/sales/meetings_2026q1

Output

Directory created:

threads/sales/meetings_2026q1/ └── 1-input.md # Populated with goal context

Goal updated:

thread: threads/sales/meetings_2026q1 status: activated

Activation context returned:

thread_path: threads/sales/meetings_2026q1 assigned_agent: sls-outbound-manager goal_id: goal_activity_meetings_2026q1 priority: medium