Course Export

Preamble: Interaction Conventions

idstack skills are designed to run in multiple CLIs (Claude Code, OpenAI Codex CLI, and others). To stay portable, skill bodies use a few concept names that have a CLI-specific implementation:

• AskUserQuestion — when a skill says "ask via AskUserQuestion" or "using AskUserQuestion",

it means: present a single numbered multiple-choice question (e.g., "Which of these best describes X? 1) ..., 2) ..., 3) Other") and stop, waiting for the user's next message before proceeding. Ask one question at a time, never batch. In Claude Code this maps to the AskUserQuestion tool; in Codex CLI (which has no analog) just emit the numbered question as plain text and wait.

• Agent / Skill (sub-task dispatch) — when a skill says "if the Agent tool is available,

dispatch X as a sub-task," that's an optimization. If your CLI has no equivalent, fall through to the inline written-out steps that follow — every skill that uses Agent ships a sequential fallback alongside it.

• Skill (cross-skill invocation) — used only by /idstack:pipeline. In Claude Code this

invokes a child skill in-process via the Skill tool. In CLIs without that primitive, the pipeline degrades to prompting the user to type the next skill name explicitly.

• Skill invocation syntax in user-facing text — when a skill prints "run /idstack:foo"

or links to /idstack:foo in a "Next steps" section, that's Claude Code's /idstack: invocation. In Codex CLI, translate to $foo (drop the /idstack: prefix, replace the leading / with $). Apply this same translation when the skill emits handoff instructions in reports, manifests, or AskUserQuestion options. Same body text, two hosts; the model translates per-CLI on output.

These are directives to the model, not magic words — interpret them as the protocol above.

Preamble: Update Check

# Locate the idstack install. Supports Claude Code (default), Codex CLI, and a
# user override via $IDSTACK_HOME.
if [ -n "${CLAUDE_PLUGIN_ROOT:-}" ]; then
  _IDSTACK="$CLAUDE_PLUGIN_ROOT"
elif [ -n "${IDSTACK_HOME:-}" ]; then
  _IDSTACK="$IDSTACK_HOME"
elif [ -d "$HOME/.agents/plugins/idstack" ]; then
  _IDSTACK="$HOME/.agents/plugins/idstack"
elif [ -d "$HOME/.agents/skills/idstack" ]; then
  _IDSTACK="$HOME/.agents/skills/idstack"
else
  # Claude Code caches marketplace plugins under a versioned dir; take the
  # highest version present. Empty if idstack was never installed this way —
  # every "$_IDSTACK/bin/..." call below is guarded, so that degrades quietly.
  _IDSTACK=$(ls -d "$HOME"/.claude/plugins/cache/idstack/idstack/*/ 2>/dev/null | sort | tail -1)
  _IDSTACK="${_IDSTACK%/}"
fi
_UPD=$("$_IDSTACK/bin/idstack-update-check" 2>/dev/null || true)
[ -n "$_UPD" ] && echo "$_UPD"

If the output contains UPDATE_AVAILABLE: tell the user "A newer version of idstack is available. Run cd $_IDSTACK && git pull && ./setup to update. (The ./setup step is required — it cleans up legacy symlinks.)" Then continue normally.

Preamble: Project Manifest

Before starting, check for an existing project manifest.

if [ -f ".idstack/project.json" ]; then
  echo "MANIFEST_EXISTS"
  "$_IDSTACK/bin/idstack-migrate" .idstack/project.json 2>/dev/null || cat .idstack/project.json
else
  echo "NO_MANIFEST"
fi

If MANIFEST_EXISTS:

• Read the manifest. If the JSON is malformed, report the specific parse error to the

user, offer to fix it, and STOP until it is valid. Never silently overwrite corrupt JSON.

• Preserve all existing sections when writing back.

If NO_MANIFEST:

• This skill will create or update the manifest during its workflow.

Preamble: Preferences

if [ -f ".idstack/project.json" ] && command -v python3 &>/dev/null; then
  python3 -c "
import json, sys
try:
    data = json.load(open('.idstack/project.json'))
    prefs = data.get('preferences', {})
    v = prefs.get('verbosity', 'normal')
    if v != 'normal':
        print(f'VERBOSITY:{v}')
except: pass
" 2>/dev/null || true
fi

If VERBOSITY:concise: Keep explanations brief. Skip evidence citations inline (still follow evidence-based recommendations, just don't cite tier codes in output). If VERBOSITY:detailed: Include full evidence citations, alternative approaches considered, and rationale for each recommendation. If VERBOSITY:normal or not shown: Default behavior — cite evidence tiers inline, explain key decisions, skip exhaustive alternatives.

Preamble: Designer Profile

_PROFILE="$HOME/.idstack/profile.yaml"
if [ -f "$_PROFILE" ]; then
  # Simple YAML parsing for experience_level (no dependency needed)
  _EXP=$(grep -E '^experience_level:' "$_PROFILE" 2>/dev/null | sed 's/experience_level:[[:space:]]*//' | tr -d '"' | tr -d "'")
  [ -n "$_EXP" ] && echo "EXPERIENCE:$_EXP"
else
  echo "NO_PROFILE"
fi

If EXPERIENCE:novice: Provide more context for recommendations. Explain WHY each step matters, not just what to do. Define jargon on first use. Offer examples. If EXPERIENCE:intermediate: Standard explanations. Assume familiarity with instructional design concepts but explain idstack-specific patterns. If EXPERIENCE:expert: Be concise. Skip basic explanations. Focus on evidence tiers, edge cases, and advanced considerations. Trust the user's domain knowledge. If NO_PROFILE: On first run, after the main workflow is underway (not before), mention: "Tip: create ~/.idstack/profile.yaml with experience_level: novice|intermediate|expert to adjust how much detail idstack provides."

Preamble: Context Recovery

Check for session history and learnings from prior runs.

# Context recovery: timeline + learnings
_HAS_TIMELINE=0
_HAS_LEARNINGS=0
if [ -f ".idstack/timeline.jsonl" ]; then
  _HAS_TIMELINE=1
  if command -v python3 &>/dev/null; then
    python3 -c "
import json, sys
lines = open('.idstack/timeline.jsonl').readlines()[-200:]
events = []
for line in lines:
    try: events.append(json.loads(line))
    except: pass
if not events:
    sys.exit(0)

# Quality score trend
scores = [e for e in events if e.get('skill') == 'course-quality-review' and 'score' in e]
if scores:
    trend = ' -> '.join(str(s['score']) for s in scores[-5:])
    print(f'QUALITY_TREND: {trend}')
    last = scores[-1]
    dims = last.get('dimensions', {})
    if dims:
        tp = dims.get('teaching_presence', '?')
        sp = dims.get('social_presence', '?')
        cp = dims.get('cognitive_presence', '?')
        print(f'LAST_PRESENCE: T={tp} S={sp} C={cp}')

# Skills completed
completed = set()
for e in events:
    if e.get('event') == 'completed':
        completed.add(e.get('skill', ''))
print(f'SKILLS_COMPLETED: {','.join(sorted(completed))}')

# Last skill run
last_completed = [e for e in events if e.get('event') == 'completed']
if last_completed:
    last = last_completed[-1]
    print(f'LAST_SKILL: {last.get(\"skill\",\"?\")} at {last.get(\"ts\",\"?\")}')

# Pipeline progression
pipeline = [
    ('needs-analysis', 'learning-objectives'),
    ('learning-objectives', 'assessment-design'),
    ('assessment-design', 'course-builder'),
    ('course-builder', 'course-quality-review'),
    ('course-quality-review', 'accessibility-review'),
    ('accessibility-review', 'red-team'),
    ('red-team', 'course-export'),
]
for prev, nxt in pipeline:
    if prev in completed and nxt not in completed:
        print(f'SUGGESTED_NEXT: {nxt}')
        break
" 2>/dev/null || true
  else
    # No python3: show last 3 skill names only
    tail -3 .idstack/timeline.jsonl 2>/dev/null | grep -o '"skill":"[^"]*"' | sed 's/"skill":"//;s/"//' | while read s; do echo "RECENT_SKILL: $s"; done
  fi
fi
if [ -f ".idstack/learnings.jsonl" ]; then
  _HAS_LEARNINGS=1
  _LEARN_COUNT=$(wc -l /dev/null | tr -d ' ')
  echo "LEARNINGS: $_LEARN_COUNT"
  if [ "$_LEARN_COUNT" -gt 0 ] 2>/dev/null; then
    "$_IDSTACK/bin/idstack-learnings-search" --limit 3 2>/dev/null || true
  fi
fi

If QUALITYTREND is shown: Synthesize a welcome-back message. Example: "Welcome back. Quality score trend: 62 -> 68 -> 72 over 3 reviews. Last skill: /learning-objectives." Keep it to 2-3 sentences. If any dimension in LASTPRESENCE is consistently below 5/10, mention it as a recurring pattern with its evidence citation.

If LASTSKILL is shown but no QUALITYTREND: Just mention the last skill run. Example: "Welcome back. Last session you ran /course-import."

If SUGGESTED_NEXT is shown: Mention the suggested next skill naturally. Example: "Based on your progress, /assessment-design is the natural next step."

If LEARNINGS > 0: Mention relevant learnings if they apply to this skill's domain. Example: "Reminder: this Canvas instance uses custom rubric formatting (discovered during import)."

---

Skill-specific manifest check: If the manifest course_export section already has data, ask the user: "I see you've already run this skill. Want to update the results or start fresh?"

Pre-Export Readiness Check

Before starting the export workflow, run the readiness dashboard:

for _p in "$CLAUDE_PLUGIN_ROOT" "$IDSTACK_HOME" "$HOME/.claude/plugins/idstack" "$HOME/.agents/plugins/idstack" "$HOME/.agents/skills/idstack"; do [ -n "$_p" ] && [ -d "$_p" ] && _IDSTACK="$_p" && break; done; : "${_IDSTACK:=$HOME/.claude/plugins/idstack}"
"$_IDSTACK/bin/idstack-status" --readiness

Show the readiness table to the user. If the verdict is:

• READY TO EXPORT: Proceed normally.
• ISSUES: Show the issues and ask: "There are unresolved issues. Continue with export anyway?"
• INCOMPLETE: Show what's missing and ask: "Some review skills haven't run yet. Continue with export anyway, or run the missing skills first?"

This is advisory — the user can always choose to export regardless.

Course Export — IMS Common Cartridge & Canvas API

You are a course export partner. Your job is to take the content generated by /course-builder and package it for import into any Learning Management System. You are the last mile between generated course content and a live course that students can access.

Two export paths:

1. IMS Common Cartridge (.imscc) — Universal format. Works with every major

LMS: Canvas, Blackboard, Moodle, D2L/Brightspace. You generate a standards- compliant package file that the instructional designer imports through their LMS admin interface. Zero API credentials needed.

1. Canvas REST API — Canvas-specific, richest integration. Pushes modules,

pages, assignments, and discussions directly to a Canvas course instance. Requires an access token. Results appear immediately in Canvas.

The output IS the course. You are not generating a spec, a plan, or a description of what the course should contain. You are generating the actual importable course content: HTML pages, assignment definitions, quiz questions, and the manifest that ties them together. The instructional designer should be able to import your output and have a functioning course shell ready for review.

You read from two sources:

• The .idstack/course-content/ directory, where /course-builder writes its

generated files (syllabus, module content, assessments, rubrics)

• The .idstack/project.json manifest, which contains the course structure,

learning objectives, and alignment data from upstream skills

Evidence Tier Key

Every recommendation includes its evidence tier in brackets:

• [T1] RCTs, meta-analyses with learning outcome measures
• [T2] Quasi-experimental with appropriate controls
• [T3] Systematic reviews (synthesis of mixed evidence)
• [T4] Observational / pre-post without comparison groups
• [T5] Expert opinion, literature reviews, theoretical frameworks

When multiple tiers apply, cite the strongest.

---

Preamble: Project Manifest and Course Content

Before starting the export, verify that generated course content exists.

if [ -f ".idstack/project.json" ]; then
  echo "MANIFEST_EXISTS"
  "$_IDSTACK/bin/idstack-migrate" .idstack/project.json 2>/dev/null || cat .idstack/project.json
else
  echo "NO_MANIFEST"
fi

if [ -d ".idstack/course-content" ]; then
  echo "CONTENT_EXISTS"
  ls -la .idstack/course-content/
else
  echo "NO_CONTENT"
fi

If NOMANIFEST or NOCONTENT: Tell the user: "I need generated course content to export. Run /course-builder first to generate your syllabus, modules, and assessments. The builder reads your manifest and produces the files I package for your LMS."

If MANIFEST_EXISTS but no course_content section: Check whether .idstack/course-content/ has files. If it does, proceed using the files directly. If not, nudge for /course-builder.

If both exist: Read the manifest. If the JSON is malformed, report the specific parse error, offer to fix it, and STOP until it is valid. Never silently proceed with corrupt data.

Preserve all existing manifest sections when writing back.

---

Prepare Course Export Folder

Every artifact this skill produces — the HTML report, the LMS package — lands under .idstack/exports//, alongside the per-skill HTML reports produced by the rest of the pipeline. Compute the slug and prepare the folder now, then reuse $_EXPORT_DIR throughout the workflow:

# Course-slug-based export folder. Required before any artifact write.
_PROJECT_NAME=$(python3 -c "import json; print(json.load(open('.idstack/project.json')).get('project_name',''))" 2>/dev/null || echo "")
_SLUG=$("$_IDSTACK/bin/idstack-slugify" "$_PROJECT_NAME" 2>/dev/null || echo "untitled-course")
_EXPORT_DIR=".idstack/exports/$_SLUG"
_REPORT_PATH="$_EXPORT_DIR/course-export.html"
mkdir -p "$_EXPORT_DIR/assets"
cp -f "$_IDSTACK/templates/assets/idstack.css" "$_EXPORT_DIR/assets/idstack.css"
echo "Course export folder: $_EXPORT_DIR"

All subsequent paths (.imscc, SCORM .zip, HTML report) write into $_EXPORT_DIR, never directly into .idstack/. The folder becomes the canonical, self-describing deliverable — open index.html to navigate, or zip the whole folder to hand to a stakeholder.

---

Export Format Selection

Ask the user how they want to export. Use AskUserQuestion:

"How do you want to export your course?"

Options:

• A) IMS Common Cartridge (.imscc) — Universal format. Import into Canvas,

Blackboard, Moodle, D2L. No API credentials needed. Produces a single file you upload through your LMS admin interface.

• B) Canvas API — Push directly to a Canvas course. Modules, pages,

assignments, and discussions appear immediately. Requires a Canvas access token and course ID.

• C) SCORM 1.2 package (.zip) — Standard e-learning format. Works with every

LMS, every authoring tool, and every corporate training platform. Produces a SCORM-compliant ZIP you upload to any LMS or host on any SCORM player.

---

Path A: IMS Common Cartridge Export

A1. Read Course Content Files

Read all files in .idstack/course-content/:

find .idstack/course-content/ -type f | sort

Read each file to understand the content structure. Expect files like:

• syllabus.md — Course syllabus
• module-01.md, module-02.md, etc. — Module content pages
• assessment-01.md, assessment-02.md, etc. — Assignment and quiz specs
• rubric-01.md, rubric-02.md, etc. — Rubric definitions
• discussion-01.md, discussion-02.md, etc. — Discussion prompts

Also read the manifest to get the course title, module structure, and ILO alignment data. The manifest provides the organizational spine; the content files provide the body.

A2. Generate imsmanifest.xml

The manifest XML defines the course structure for the LMS. Generate it following the IMS Common Cartridge 1.3 specification:

  
    IMS Common Cartridge
    1.3.0
    
      
        {course title}
      
    
  
  
    
      
        
        
          {Module 1 Title}
          
          
            {Page Title}

…

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [savvides](https://github.com/savvides)
- **Source:** [savvides/idstack](https://github.com/savvides/idstack)
- **License:** MIT

Install and usage instructions live in the source repository linked above.