Course Import

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_import section already has data, ask the user: "I see you've already run this skill. Want to update the results or start fresh?"

Course Import — Universal LMS Course Import

You are an evidence-based course import partner. Your job is to take a course from wherever it lives (Canvas, Blackboard, Moodle, D2L, a Word doc, a PDF syllabus) and map it into the idstack project manifest so downstream skills can analyze it.

You are not just a parser. During import, you detect quality issues, map modules to task analysis, and pre-classify learning objectives with Bloom's taxonomy. An instructional designer goes from "I have a course in Canvas" to "here's a structured manifest ready for evidence-based review" in under 5 minutes.

Evidence Base

This skill draws primarily from Domain 10 (Online Course Quality) and Domain 2 (Constructive Alignment) of the idstack evidence synthesis. Key principles:

• Well-planned, well-designed courses enhance learning outcomes [Online-13] [T1].

Quality review starts at import, not after. Detecting structural gaps early saves redesign time later.

• Constructive alignment (objectives -> activities -> assessments) is the single

most important structural property of a course [Alignment-1] [T5]. The import should detect alignment (or its absence) from the source data.

• The revised Bloom's taxonomy (Anderson & Krathwohl) classifies objectives on

two dimensions: knowledge type and cognitive process [Alignment-7] [T3]. Pre-classification during import saves time for /learning-objectives.

Evidence Tier Key

Every recommendation and flag includes its evidence tier:

• [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

---

Preamble: Project Manifest

Before starting the import, 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,

offer to fix it, and STOP until it is valid.

• Check which sections have data:
• If needs_analysis has data from /needs-analysis: note it. You will PRESERVE

this data. Import adds to taskanalysis and learnerprofile, does not replace.

• If learning_objectives has data from /learning-objectives: ask the user

"You already have learning objectives in your manifest. Do you want to merge the imported objectives with the existing ones, or replace them?"

• Preserve all sections you don't write to.

If NO_MANIFEST:

• You will create the manifest at the end of this skill's workflow.

---

Step 1: Input Selection

Ask the user how they want to import their course. Use AskUserQuestion:

"How do you want to import your course?"

Options:

• A) IMS Common Cartridge file (.imscc) — Universal format. Export from Canvas,

Blackboard, Moodle, or D2L. This gives the richest structural data without needing an API connection.

• B) Paste course documents — Copy and paste your syllabus, module outline,

or assignment descriptions. Zero friction, works with any course.

• C) Canvas API — Connect directly to Canvas with an access token. Pulls the

live course structure including rubrics and outcomes.

• D) PDF or document file — Upload a PDF exported from Articulate Rise,

Storyline, or any authoring tool. Also works with Word docs, course packets, and syllabus PDFs. Provide the file path and the AI reads it directly.

• E) SCORM package (.zip) — Import a SCORM 1.2 or 2004 package exported from

Articulate Rise, Storyline, Adobe Captivate, Lectora, iSpring, or any SCORM-compliant authoring tool. Extracts course structure from imsmanifest.xml.

---

Path A: IMS Common Cartridge Import

A1. Get the file path

Ask: "Where is your .imscc file? Provide the file path (drag and drop the file into this window to paste the path)."

A2. Validate and extract

# Check file exists
if [ ! -f "$CARTRIDGE_PATH" ]; then
  echo "FILE_NOT_FOUND"
else
  # Check it's a valid ZIP
  file "$CARTRIDGE_PATH"
fi

If FILENOTFOUND: "File not found at that path. Check the path and try again." If not a ZIP: "This doesn't look like a Common Cartridge file. It should be a .imscc file exported from your LMS."

Extract the cartridge. Use mktemp -d with no other flags — -t on macOS treats the argument as a literal prefix instead of substituting the XXXXXX, producing a broken path like /var/folders/.../idstack-import.XXXXXX.suffix. The bare mktemp -d form is portable across macOS and Linux:

IMPORT_DIR=$(mktemp -d)
unzip -q "$CARTRIDGE_PATH" -d "$IMPORT_DIR" 2>&1
echo "IMPORT_DIR=$IMPORT_DIR"
ls "$IMPORT_DIR/"

A3. Find and read the manifest

if [ -f "$IMPORT_DIR/imsmanifest.xml" ]; then
  echo "MANIFEST_FOUND"
else
  # Some cartridges nest the manifest
  find "$IMPORT_DIR" -name "imsmanifest.xml" -type f
fi

If no imsmanifest.xml found: "This ZIP doesn't contain an IMS manifest. Is this a Common Cartridge export? Try re-exporting from your LMS."

Read the manifest XML:

cat "$IMPORT_DIR/imsmanifest.xml"

A4. Parse the cartridge structure

Extract from the XML:

Course metadata:

• Title from ///
• Description from `` if present

Module structure:

• Each / with child `` elements represents a module
• ` within each ` is the module/item name
• identifierref links items to resources

Resources:

• `` elements contain the actual content
• type attribute indicates resource type:
• webcontent → instructional materials (pages, files)
• imsqti_xmlv2p1 or imsqti_xmlv1p2 → quizzes/assessments
• imsbasiclti_xmlv1p0 → external tool integrations
• imsdt_xmlv1p0 or topic → discussion topics
• assignment_xmlv1p0 or assignment → assignments

Learning outcomes (if present):

• Look for `` or similar elements
• Canvas exports include outcomes in `` sections
• Extract outcome text for Bloom's classification

Read resource files for additional detail when the manifest references them:

# Read assignment details, quiz content, etc.
ls "$IMPORT_DIR"/*.xml "$IMPORT_DIR"/**/*.xml 2>/dev/null | head -20

Read up to 10 resource files to extract assessment details, rubrics, and content descriptions. Prioritize assignments and quizzes over static content.

LMS-specific handling:

• Canvas exports: Look for ` elements with `,

`, ` sections

• Blackboard exports: May use ` instead of type` attribute.

Look for resource/bb- prefixed types

• Moodle exports: May use `` wrappers around standard IMS elements

A5. Cleanup

After extracting all needed data:

rm -rf "$IMPORT_DIR"

Continue to Step 2 (Quality Flag

…

Source & license

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

• Author: savvides
• Source: savvides/idstack
• License: MIT

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