Skill Grant

Grant Skill

Thin wrapper that delegates grant work to grant-agent subagent.

IMPORTANT: This skill implements the skill-internal postflight pattern. After the subagent returns, this skill handles all postflight operations (status update, artifact linking, git commit) before returning. This eliminates the "continue" prompt issue between skill return and orchestrator.

Context References

Reference (do not load eagerly):

• Path: .claude/context/formats/return-metadata-file.md - Metadata file schema
• Path: .claude/context/patterns/postflight-control.md - Marker file protocol
• Path: .claude/context/patterns/file-metadata-exchange.md - File I/O helpers
• Path: .claude/context/patterns/jq-escaping-workarounds.md - jq escaping patterns (Issue #1132)

Note: This skill is a thin wrapper with internal postflight. Context is loaded by the delegated agent.

Trigger Conditions

This skill activates when:

• Task type is "present" and task_type is "grant"
• Grant workflow requested via flags (--draft, --budget) or /implement routing
• Present extension is available

Workflow Type Routing

This skill routes to grant-agent with one of five workflow types:

Note: The assemble workflow is triggered via /implement N command (not /grant), which routes to skill-grant when the task type is "present" and task_type is "grant".

Input Parameters

Required Parameters

• task_number - Task number (must exist in state.json with language="present" and task_type="grant")
• workflow_type - One of: funder_research, proposal_draft, budget_develop, progress_track, assemble
• session_id - Session ID from orchestrator

Optional Parameters

• focus - Focus prompt for workflow direction (used by all workflow types)

Prompt Usage by Workflow Type:

Execution Flow

Stage 1: Input Validation

Validate required inputs:

• task_number - Must be provided and exist in state.json
• workflow_type - Must be one of: funder_research, proposal_draft, budget_develop, progress_track, assemble
• focus - Optional prompt for workflow direction

# Lookup task
task_data=$(jq -r --argjson num "$task_number" \
  '.active_projects[] | select(.project_number == $num)' \
  specs/state.json)

# Validate exists
if [ -z "$task_data" ]; then
  return error "Task $task_number not found"
fi

# Extract fields
task_type=$(echo "$task_data" | jq -r '.task_type // "present"')
status=$(echo "$task_data" | jq -r '.status')
project_name=$(echo "$task_data" | jq -r '.project_name')
description=$(echo "$task_data" | jq -r '.description // ""')

# Validate language is "present"
if [ "$task_type" != "present" ]; then
  return error "Task $task_number has language '$task_type', expected 'present'"
fi

# Validate workflow_type
case "$workflow_type" in
  funder_research|proposal_draft|budget_develop|progress_track|assemble|fix_it_scan)
    ;;
  *)
    return error "Invalid workflow_type: $workflow_type. Expected one of: funder_research, proposal_draft, budget_develop, progress_track, assemble, fix_it_scan"
    ;;
esac

Stage 2: Preflight Status Update

Update task status based on workflow type BEFORE invoking subagent.

Status Mapping by Workflow Type:

Update state.json (for workflows that change status):

# Determine preflight status based on workflow type
case "$workflow_type" in
  funder_research)
    preflight_status="researching"
    preflight_marker="[RESEARCHING]"
    ;;
  proposal_draft|budget_develop)
    preflight_status="planning"
    preflight_marker="[PLANNING]"
    ;;
  progress_track)
    preflight_status=""  # No status change
    preflight_marker=""
    ;;
  assemble)
    preflight_status="implementing"
    preflight_marker="[IMPLEMENTING]"
    ;;
  fix_it_scan)
    preflight_status=""  # No status change (non-destructive scan)
    preflight_marker=""
    ;;
esac

# Update state.json if status change needed
if [ -n "$preflight_status" ]; then
  bash .claude/scripts/state-write.sh \
    '(.active_projects[] | select(.project_number == $num)) |= . + {
      status: $status,
      last_updated: $ts,
      session_id: $sid
    }' \
    --session-id "$session_id" \
    --argjson num "$task_number" \
    --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
    --arg status "$preflight_status" \
    --arg sid "$session_id"
fi

Update TODO.md: Use Edit tool to change status marker to the workflow-specific in-progress state.

Update plan file (for assemble workflow only):

# Update plan file status for assemble workflow
if [ "$workflow_type" = "assemble" ]; then
    .claude/scripts/update-plan-status.sh "$task_number" "$project_name" "IMPLEMENTING" 2>/dev/null || true
fi

Stage 3: Create Postflight Marker

Source skill-base.sh once, then follow @.claude/context/patterns/skill-preflight-flow.md's Stage 3 (marker creation) — the preceding Stage 2 status transition is intentionally left as its own conditional block above (per-workflow-type dispatch, including the progress_track and fix_it_scan no-status-change cases, is a domain-specific behavior this conversion does not restructure), only the marker write itself moves onto the shared function:

source .claude/scripts/skill-base.sh
padded_num=$(printf "%03d" "$task_number")
skill_name="skill-grant"
skill_create_postflight_marker "$padded_num" "$project_name" "$session_id" "$skill_name" "$workflow_type"

Stage 4: Prepare Delegation Context

Extract pre-gathered forcing_data (if present from Stage 0):

# Extract forcing_data from task metadata
forcing_data=$(echo "$task_data" | jq -r '.forcing_data // null')

Detect revision mode (for assemble workflow):

# Check if task has parent_grant field (indicates revision task)
parent_grant=$(echo "$task_data" | jq -r '.parent_grant // ""')
revises_directory=$(echo "$task_data" | jq -r '.revises_directory // ""')

if [ -n "$parent_grant" ] && [ "$workflow_type" = "assemble" ]; then
    is_revision="true"
    # Validate revises_directory exists
    if [ ! -d "$revises_directory" ]; then
        return error "Revision target not found: $revises_directory"
    fi
else
    is_revision="false"
    revises_directory=""
fi

Prepare delegation context for the subagent:

{
  "session_id": "sess_{timestamp}_{random}",
  "delegation_depth": 1,
  "delegation_path": ["orchestrator", "grant", "skill-grant"],
  "timeout": 3600,
  "task_context": {
    "task_number": N,
    "task_name": "{project_name}",
    "description": "{description}",
    "task_type": "present",
    "task_type": "grant"
  },
  "workflow_type": "funder_research|proposal_draft|budget_develop|progress_track|assemble",
  "focus_prompt": "{optional focus - passed to agent for guidance}",
  "forcing_data": "{pre-gathered forcing data from Stage 0, or null}",
  "is_revision": "{boolean - true if task has parent_grant field}",
  "revises_directory": "{grants/{N}_{slug}/ - path to existing grant if revision}",
  "metadata_file_path": "specs/{NNN}_{SLUG}/.return-meta.json"
}

Stage 5: Invoke Subagent

CRITICAL: You MUST use the Agent tool to spawn the subagent.

Required Tool Invocation:

Tool: Agent (NOT Skill, NOT Plan)
Parameters:
  - subagent_type: "grant-agent"
  - prompt: [Include task_context, delegation_context, workflow_type, focus_prompt, is_revision, revises_directory, metadata_file_path]
  - description: "Execute {workflow_type} workflow for task {N}"

DO NOT use Skill(grant-agent) - this will FAIL.

The subagent will:

• Execute the specified workflow (funder_research, proposal_draft, budget_develop, progress_track, assemble)
• Use the focus_prompt to guide its output
• Create workflow-specific artifacts in specs/{NNN}_{SLUG}/{subdir}/
• Write metadata to specs/{NNN}_{SLUG}/.return-meta.json
• Return a brief text summary (NOT JSON)

Stage 5a: Validate Return Format

Validate the return format:

If subagent returned JSON to console:
  - Log warning: "Subagent returned JSON to console instead of brief summary"
  - Continue with metadata file parsing (Stage 6)

If subagent returned brief text summary:
  - This is expected behavior
  - Continue to Stage 6

Stage 5b: Self-Execution Fallback

CRITICAL: If you performed the work above WITHOUT using the Agent tool (i.e., you read files, wrote artifacts, or updated metadata directly instead of spawning a subagent), you MUST write a .return-meta.json file now before proceeding to postflight. Use the schema from return-metadata-file.md with the appropriate status value for this operation.

If you DID use the Agent tool, skip this stage -- the subagent already wrote the metadata.

Postflight (ALWAYS EXECUTE)

The following stages MUST execute after work is complete, whether the work was done by a subagent or inline (Stage 5b). Do NOT skip these stages for any reason.

Stage 6: Read Metadata File

Read the metadata file:

metadata_file="specs/${padded_num}_${project_name}/.return-meta.json"

if [ -f "$metadata_file" ] && jq empty "$metadata_file" 2>/dev/null; then
    meta_status=$(jq -r '.status' "$metadata_file")
    artifact_path=$(jq -r '.artifacts[0].path // ""' "$metadata_file")
    artifact_type=$(jq -r '.artifacts[0].type // ""' "$metadata_file")
    artifact_summary=$(jq -r '.artifacts[0].summary // ""' "$metadata_file")
else
    echo "Error: Invalid or missing metadata file"
    meta_status="failed"
fi

Handle in_progress status: If metadata file shows status: "in_progress", the subagent was interrupted:

if [ "$meta_status" = "in_progress" ]; then
    # Extract partial progress info
    partial_stage=$(jq -r '.partial_progress.stage // "unknown"' "$metadata_file")
    partial_details=$(jq -r '.partial_progress.details // ""' "$metadata_file")

    # Keep preflight status (researching, planning)
    # Do not cleanup - resume is possible
    echo "Subagent interrupted at stage: $partial_stage"
    echo "Details: $partial_details"
fi

Stage 7: Update Task Status (Postflight)

Map workflow_type + metadata status to final state.json status:

Postflight Status Mapping:

Update state.json (if status changed to success):

# Determine postflight status based on workflow type and meta_status
case "$workflow_type" in
  funder_research)
    if [ "$meta_status" = "researched" ]; then
      postflight_status="researched"
      postflight_marker="[RESEARCHED]"
    fi
    ;;
  proposal_draft|budget_develop)
    if [ "$meta_status" = "drafted" ]; then
      postflight_status="planned"
      postflight_marker="[PLANNED]"
    fi
    ;;
  progress_track)
    postflight_status=""  # No status change for progress tracking
    postflight_marker=""
    ;;
  assemble)
    if [ "$meta_status" = "assembled" ]; then
      postflight_status="completed"
      postflight_marker="[COMPLETED]"
    fi
    ;;
  fix_it_scan)
    postflight_status=""  # No status change for fix-it scan
    postflight_marker=""
    ;;
esac

# Update state.json if status change to success
if [ -n "$postflight_status" ]; then
  bash .claude/scripts/state-write.sh \
    '(.active_projects[] | select(.project_number == $num)) |= . + {
      status: $status,
      last_updated: $ts
    }' \
    --session-id "$session_id" \
    --argjson num "$task_number" \
    --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
    --arg status "$postflight_status"
fi

Update TODO.md: Use Edit tool to change status marker to the final success state.

Update plan file (for assemble workflow):

# Update plan file status for assemble workflow
if [ "$workflow_type" = "assemble" ]; then
    if [ "$meta_status" = "assembled" ]; then
        .claude/scripts/update-plan-status.sh "$task_number" "$project_name" "COMPLETED" 2>/dev/null || true
    elif [ "$meta_status" = "partial" ]; then
        .claude/scripts/update-plan-status.sh "$task_number" "$project_name" "PARTIAL" 2>/dev/null || true
    fi
fi

On partial/failed: Keep status at preflight level for resume.

Stage 8: Link Artifacts

Add artifact to state.json with summary.

IMPORTANT: Use two-step jq pattern to avoid Issue #1132 escaping bug. See jq-escaping-workarounds.md.

Determine artifact type for filtering:

# Map workflow_type to artifact type for state.json
case "$workflow_type" in
  funder_research)
    artifact_filter_type="report"
    ;;
  proposal_draft)
    artifact_filter_type="draft"
    ;;
  budget_develop)
    artifact_filter_type="budget"
    ;;
  progress_track)
    artifact_filter_type="summary"
    ;;
  assemble)
    artifact_filter_type="grant"
    ;;
esac

Update state.json with artifact:

if [ -n "$artifact_path" ]; then
    # Step 1: Filter out existing artifacts of same type (use "| not" pattern to avoid != escaping - Issue #1132)
    bash .claude/scripts/state-write.sh \
      '(.active_projects[] | select(.project_number == $num)).artifacts =
        [(.active_projects[] | select(.project_number == $num)).artifacts // [] | .[] | select(.type == $filter_type | not)]' \
      --session-id "$session_id" \
      --argjson num "$task_number" \
      --arg filter_type "$artifact_filter_type"

    # Step 2: Add new artifact
    bash .claude/scripts/state-write.sh \
      '(.active_projects[] | select(.project_number == $num)).artifacts += [{"path": $path, "type": $type, "summary": $summary}]' \
      --session-id "$session_id" \
      --argjson num "$task_number" \
      --arg path "$artifact_path" \
      --arg type "$artifact_type" \
      --arg summary "$artifact_summary"
fi

Update TODO.md: Link artifact using count-aware format. Apply the four-case Edit logic from @.claude/context/patterns/artifact-linking-todo.md.

Artifact type labels and parameterization:

• funder_research: field_name=**Research**, next_field=**Plan**
• proposal_draft: field_name=**Draft**, next_field=**Description**
• budget_develop: field_name=**Budget**, next_field=**Description**
• progress_track: field_name=**Progress**, next_field=**Description**
• assemble: field_name=**Grant**, next_field=**Description**

Stage 9: Git Commit

Commit changes with session ID:

# Commit message based on workflow type
case "$workflow_type" in
  funder_research)
    commit_action="complete funder research"
    ;;
  proposal_draft)
    commit_action="create proposal draft"
    ;;
  budget_develop)
    commit_action="develop budget"
    ;;
  progress_track)
    commit_action="update progress"
    ;;
  assemble)
    commit_action="assemble grant materials"
    ;;
esac

# Targeted staging per .claude/context/standards/git-staging-scope.md — never a repo-wide add
padded_num=$(printf "%03d" "$task_number")
git add "specs/${padded_num}_${project_name}/" "specs/TODO.md" "specs/state.json"
git commit -m "task ${task_number}: ${commit_action}

Session: ${session_id}

On commit failure: Non-blocking. Log the failure but continue with success response.

Stage 10: Cleanup

Follow @.claude/context/patterns/skill-postflight-flow.md's Stage 9 (cleanup):

skill_cleanup "$padded_num" "$project_name"

Stage 11: Return Brief Summary

Return a brief text summary (NOT JSON) based on workflow type.

Funder Research Success:

Funder research completed for task {N}:
- Identified {count} potential funders matching criteria
- Top recommendation: {funder_name} ({reason})
- Created report at specs/{NNN}_{SLUG}/reports/{MM}_funder-analysis.md
- Status updated to [RESEARCHED]
- Changes committed with session {session_id}

Proposal Draft Success:

Proposal draft created for task {N}:
- Drafted {count} of {total} required sections
- Focus applied: "{focus_prompt}" (if provided)
- Created draft at specs/{NNN}_{SLUG}/drafts/{MM}_narrative-draft.md
- Status updated to [PLANNED]
- Recommend: Run /grant {N} --budget next, then /plan {N}

Budget Development Success:

Budget developed for task {N}:
- Created {count} line items across {categories} categories
- Total budget: {amount}
- Focus applied: "{focus_prompt}" (if provided)
- Created budget at specs/{NNN}_{SLUG}/budgets/{MM}_line-item-budget.md
- Status updated to [PLANNED]
- Recommend: Run /plan {N} to create implementation plan

Assemble Success:

Grant materials assembled for task {N}:
- Output directory: grants/{N}_{slug}/
- Files created: narrative.md, budget.md, checklist.md
- Assembly options applied: "{focus_prompt}" (if provided)
- Status updated to [COMPLETED]
- Changes committed with session {session_id}

Progress Tracking Success:

Progress summary updated for task {N}:
- Overall completion: {percentage}%
- {completed_count} sections completed, {pending_count} in progress
- Created summary at specs/{NNN}_{SLUG}/summaries/{MM}_progress-summary.md
- Status unchanged (progress tracking only)
- Changes committed with session {session_id}

Partial Return:

Grant {workflow_type} partially completed for task {N}:
- {completed_actions}
- {failed_action} failed: {reason}
- Partial artifact created at specs/{NNN}_{SLUG}/{subdir}/{filename}
- Status remains [{preflight_marker}] - run /grant {N} {flag} to continue

Fix-It Scan Workflow (Direct Execution)

When workflow_type=fix_it_scan, this skill performs direct execution (no subagent) following the interactive tag scanning pattern from /fix-it.

IMPORTANT: This workflow does NOT delegate to a subagent. It executes all steps directly within the skill context.

Step F1: Locate Grant Directory

# Check for grant directory in specs/ (active task)
padded_num=$(printf "%03d" "$task_number")
if [ -d "specs/${padded_num}_${project_name}" ]; then
    grant_dir="specs/${padded_num}_${project_name}"
# Check for grant directory in grants/ (completed grant)
elif [ -d "grants/${task_number}_${project_name}" ]; then
    grant_dir="grants/${task_number}_${project_name}"
else
    return error "Grant directory not found for task ${task_number}. Checked:
    - specs/${padded_num}_${project_name}/
    - grants/${task_number}_${project_name}/"
fi

Step F2: Scan for Tags

Extract tags from grant-specific file types (.tex, .md, .bib):

# Initialize tag arrays
declare -a fix_tags
declare -a note_tags
declare -a todo_tags
declare -a question_tags

# Scan LaTeX files (% comment prefix)
while IFS= read -r line; do
    fix_tags+=("$line")
done < <(grep -rn --include="*.tex" "% FIX:" "$grant_dir" 2>/dev/null || true)

while IFS= read -r line; do
    note_tags+=("$line")
done < <(grep -rn --include="*.tex" "% NOTE:" "$grant_dir" 2>/dev/null || true)

while IFS= read -r line; do
    todo_tags+=("$line")
done < <(grep -rn --include="*.tex" "% TODO:" "$grant_dir" 2>/dev/null || true)

while IFS= read -r line; do
    question_tags+=("$line")
done < <(grep -rn --include="*.tex" "% QUESTION:" "$grant_dir" 2>/dev/null || true)

# Scan Markdown files (<!-- comment prefix)
while IFS= read -r line; do
    fix_tags+=("$line")
done < <(grep -rn --include="*.md" "<!-- FIX:" "$grant_dir" 2>/dev/null || true)

while IFS= read -r line; do
    note_tags+=("$line")
done < <(grep -rn --include="*.md" "<!-- NOTE:" "$grant_dir" 2>/dev/null || true)

while IFS= read -r line; do
    todo_tags+=("$line")
done < <(grep -rn --include="*.md" "<!-- TODO:" "$grant_dir" 2>/dev/null || true)

while IFS= read -r line; do
    question_tags+=("$line")
done < <(grep -rn --include="*.md" "<!-- QUESTION:" "$grant_dir" 2>/dev/null || true)

# Scan BibTeX files (% comment prefix)
while IFS= read -r line; do
    fix_tags+=("$line")
done < <(grep -rn --include="*.bib" "% FIX:" "$grant_dir" 2>/dev/null || true)

while IFS= read -r line; do
    note_tags+=("$line")
done < <(grep -rn --include="*.bib" "% NOTE:" "$grant_dir" 2>/dev/null || true)

while IFS= read -r line; do
    todo_tags+=("$line")
done < <(grep -rn --include="*.bib" "% TODO:" "$grant_dir" 2>/dev/null || true)

while IFS= read -r line; do
    question_tags+=("$line")
done < <(grep -rn --include="*.bib" "% QUESTION:" "$grant_dir" 2>/dev/null || true)

Step F3: Early Exit if No Tags

total_tags=$((${#fix_tags[@]} + ${#note_tags[@]} + ${#todo_tags[@]} + ${#question_tags[@]}))

if [ "$total_tags" -eq 0 ]; then
    echo "## No Tags Found"
    echo ""
    echo "Scanned files in: $grant_dir"
    echo "No FIX:, NOTE:, TODO:, or QUESTION: tags detected."
    echo ""
    echo "Nothing to create."
    return 0  # Not an error - just no work to do
fi

Step F4: Display Tag Summary

## Tag Scan Results

**Grant Directory**: {grant_dir}
**Tags Found**: {total_tags}

### FIX: Tags ({count})
- `{file}:{line}` - {message}
...

### NOTE: Tags ({count})
- `{file}:{line}` - {message}
...

### TODO: Tags ({count})
- `{file}:{line}` - {message}
...

### QUESTION: Tags ({count})
- `{file}:{line}` - {message}
...

Step F5: Interactive Task Type Selection

Use AskUserQuestion to let user select which task types to create:

{
  "question": "Which task types should be created from grant tags?",
  "header": "Grant Task Types",
  "multiSelect": true,
  "options": [
    {"label": "FIX: Combined fix task", "description": "Combine {N} FIX:/NOTE: tags into single task"},
    {"label": "NOTE: Documentation task", "description": "Update context from {N} NOTE: tags"},
    {"label": "TODO: Individual tasks", "description": "Create tasks for {N} TODO: items"},
    {"label": "QUESTION: Research tasks", "description": "Create research tasks for {N} QUESTION: items"}
  ]
}

Only show options for tag types that were found.

Step F6: Individual TODO Selection (if TODO selected)

If user selected TODO tasks, prompt for individual selection:

{
  "question": "Select TODO items to create as tasks:",
  "header": "TODO Selection",
  "multiSelect": true,
  "options": [
    {"label": "{TODO message}", "description": "{file}:{line}"},
    ...
  ]
}

For >20 TODO items, add "Select all" option.

Step F7: TODO Topic Grouping (if 2+ TODOs selected)

When multiple TODOs are selected, offer grouping options:

{
  "question": "How should TODO items be grouped into tasks?",
  "header": "Topic Grouping",
  "multiSelect": false,
  "options": [
    {"label": "Accept suggested topic groups", "description": "Creates {N} grouped tasks based on shared topics"},
    {"label": "Keep as separate tasks", "description": "Creates {N} individual tasks"},
    {"label": "Create single combined task", "description": "Creates 1 task containing all items"}
  ]
}

Topic detection uses:

• Shared key terms in TODO messages
• Same file proximity
• Section similarity (based on line numbers)

Step F8: Individual QUESTION Selection (if QUESTION selected)

If user selected QUESTION tasks, prompt for individual selection:

{
  "question": "Select QUESTION items to create as research tasks:",
  "header": "QUESTION Selection",
  "multiSelect": true,
  "options": [
    {"label": "{QUESTION message}", "description": "{file}:{line}"},
    ...
  ]
}

Step F9: QUESTION Topic Grouping (if 2+ QUESTIONs selected)

When multiple QUESTIONs are selected, offer grouping options (same pattern as TODO).

Step F10: Create Tasks

For each selected task type, create tasks with language="present" and task_type="grant":

FIX Task Creation:

next_num=$(jq -r '.next_project_number' specs/state.json)
slug="fix_grant_${task_number}_issues"
description="Fix embedded FIX: and NOTE: issues in grant ${task_number}"

# Update state.json
bash .claude/scripts/state-write.sh \
  '.next_project_number = ($next_num + 1) |
   .active_projects = [{
     "project_number": $next_num,
     "project_name": $slug,
     "status": "not_started",
     "task_type": "present",
     "task_type": "grant",
     "description": $desc,
     "parent_task": $parent,
     "created": $ts,
     "last_updated": $ts
   }] + .active_projects' \
  --session-id "$session_id" \
  --argjson next_num "$next_num" \
  --arg slug "$slug" \
  --arg ts "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
  --arg desc "$description" \
  --argjson parent "$task_number"

TODO Task Creation (per selected/grouped item):

# Same pattern, with language="present", task_type="grant" and parent_task=$task_number

QUESTION Task Creation (per selected/grouped item):

# Same pattern, with language="present", task_type="grant" and parent_task=$task_number

Step F11: Update TODO.md

For each created task, prepend entry to TODO.md ## Tasks section:

### {NEW_N}. {Title}
- **Effort**: TBD
- **Status**: [NOT STARTED]
- **Task Type**: grant
- **Parent Task**: Task #{N}

**Description**: {description}

Step F12: Git Commit

git add specs/state.json specs/TODO.md
git commit -m "task ${task_number}: create fix-it tasks from grant tags

Created {count} tasks from embedded tags in grant directory.

Session: ${session_id}

Step F13: Return Summary

Grant fix-it scan completed for task {N}:
- Scanned: {grant_dir}
- Tags found: {total_tags} (FIX: {fix_count}, NOTE: {note_count}, TODO: {todo_count}, QUESTION: {question_count})
- Tasks created: {created_count}
- Created task numbers: #{X}, #{Y}, #{Z}
- Parent grant status unchanged
- Changes committed with session {session_id}

Next steps:
- /research {NEW_N} to begin work on created tasks
- Review tasks in TODO.md

Error Handling

Input Validation Errors

Task not found: Return immediately with error message:

Grant skill error for task {N}:
- Task not found in state.json
- Verify task exists with /task --sync
- No status changes made

Invalid workflow_type: Return immediately with error message:

Grant skill error for task {N}:
- Invalid workflow_type: {provided_value}
- Expected one of: funder_research, proposal_draft, budget_develop, progress_track, assemble, fix_it_scan
- No status changes made

Wrong language: Return immediately with error message:

Grant skill error for task {N}:
- Task has language '{language}', expected 'present'
- Use /grant {N} to update task type or use appropriate skill
- No status changes made

Metadata File Missing

If subagent didn't write metadata file:

1. Keep status at preflight level (researching, planning)
2. Do not cleanup postflight marker
3. Report error to user with resume guidance

Grant skill error for task {N}:
- Subagent did not write metadata file
- Task remains [{preflight_marker}] for resume
- Postflight marker preserved
- Run /grant {N} {flag} to retry

Git Commit Failure

Non-blocking error. Log failure but continue with success response:

Grant {workflow_type} completed for task {N}:
- {workflow_results}
- [Warning] Git commit failed: {error}
- Manual commit recommended: review `git status --short`, then stage only the task directory
  (`specs/{padded}_{slug}/`) plus `specs/TODO.md` and `specs/state.json` before committing

Subagent Timeout

Return partial status if subagent times out (default 3600s):

1. Check for partial metadata file (may have in_progress status)
2. Keep status at preflight level for resume
3. Report partial progress if available

Grant {workflow_type} timed out for task {N}:
- Subagent exceeded timeout limit
- Partial progress: {partial_details}
- Status remains [{preflight_marker}]
- Run /grant {N} {flag} to continue

Fix-It Scan Errors

Grant directory not found:

Grant fix-it scan error for task {N}:
- Grant directory not found
- Checked: specs/{NNN}_{project_name}/ and grants/{N}_{project_name}/
- No tasks created
- Ensure grant directory exists before running fix-it scan

No tags found (not an error - informational):

Grant fix-it scan completed for task {N}:
- Scanned: {grant_dir}
- No FIX:, NOTE:, TODO:, or QUESTION: tags found
- Nothing to create

Empty selection (user selected nothing):

Grant fix-it scan completed for task {N}:
- Tags found: {total_tags}
- No task types selected
- No tasks created

Git commit failure (non-blocking):

Grant fix-it scan completed for task {N}:
- Tasks created: {count}
- [Warning] Git commit failed: {error}
- Manual commit recommended: git add specs/ && git commit

MUST NOT (Postflight Boundary)

After the agent returns -- whether with a success, partial, or failed status -- this skill MUST proceed immediately to postflight (Stage 6). This applies across all of this skill's workflow_type variants (research, plan, and assemble/implementation alike). The skill MUST NOT:

1. Edit source/report/deck files - All workflow-type-specific work is done by agent
2. Run domain analysis or calculations - Analysis is agent work
3. Use MCP or WebSearch tools - Domain tools are for agent use only
4. Analyze or grep source - Analysis is agent work
5. Write artifacts - Artifact creation is done by agent

PROHIBITION: If the subagent returned partial or failed status, the lead skill MUST NOT attempt to continue, complete, or "fill in" the subagent's work. Report the partial/failed status and let the user re-run the triggering command to resume.

The postflight phase is LIMITED TO:

• Reading agent metadata file
• Calling update-task-status.sh for status updates (state.json + TODO.md), per the workflow-type-specific mapping documented in this skill's own preflight stage
• Linking artifacts in state.json
• Git commit
• Cleanup of temp/marker files

Reference: @.claude/context/standards/postflight-tool-restrictions.md

Return Format

This skill returns a brief text summary (NOT JSON). The JSON metadata is written to the file and processed internally.

Example successful return (proposal_draft with prompt):

Proposal draft created for task {N}:
- Drafted 5 of 7 required sections
- Focus applied: "Emphasize innovation and methodology"
- Created draft at specs/500_research_ai_safety_funders/drafts/01_narrative-draft.md
- Status updated to [PLANNED]
- Recommend: Run /grant 500 --budget next

Example partial return:

Grant proposal_draft partially completed for task {N}:
- Completed problem statement, methodology, impact sections
- WebFetch failed for funder template retrieval
- Partial draft saved at specs/500_research_ai_safety_funders/drafts/01_narrative-draft.md
- Status remains [PLANNING] - run /grant 500 --draft to continue

Example failed return:

Grant skill error for task {N}:
- Task not found in state.json
- No artifacts created
- No status changes made
- Verify task exists with /task --sync