@jenga-ai/agent 1.0.0

package/skills/commit/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: commit
+description: Commit implemented epic, story, or task work using the EST naming convention. Also handles user-action prerequisites and new-epic boundaries. Use after completing any EST work item.
+keywords:
+  - commit
+  - save
+  - git commit
+  - done
+  - push
+examples:
+  - "commit this work"
+  - "save my changes"
+---
+
+# Commit — Commit Completed Work
+
+## Instructions
+
+If no epic, task, or story has been implemented, exit with the message: "No implementation to commit."
+
+1. **Verify user-action prerequisites** — Check whether an `_INSTRUCTIONS.md` file exists for this task at `project/board/tasks/<E##_S##_T##>_INSTRUCTIONS.md`. If the task has out-of-scope prerequisites but no instructions file was created, create one now using `assets/user_instructions_template.md`. If one already exists, surface it to the user as a reminder. (The developer should have created this file during task intake — this is a final safety check.)
+
+2. **Commit** using the following format:
+   - **Epic:** `epic(<Epic Title>): <MAX_50_CHAR_SUMMARY>`
+   - **Task/Story:** `story(<Epic Title>_<Story Title>): <MAX_50_CHAR_SUMMARY>`
+   
+   **Fallback: Group changes logically** — prefer one commit per coherent unit of work, but don't force splits. When in doubt, keep it together.
+
+3. **Check for next epic** — If a new epic is to be started, inform the user that a new conversation should be initiated. If there are no subsequent epics left, show the message: "All Done! 🎉"

package/skills/commit/assets/user_instructions_template.md

@@ -0,0 +1,22 @@
+# <Action Name> — Setup Instructions
+
+**Epic**: E## — <epic title>
+**Required before**: <story or task that depends on this>
+
+## Overview
+
+<Brief description of what the user needs to set up and why.>
+
+## Steps
+
+1. <Step one>
+2. <Step two>
+3. <Step three>
+
+## Verification
+
+<How the user can confirm the setup is complete and working.>
+
+## Notes
+
+<Any caveats, links to external docs, or environment-specific instructions.>

package/skills/continue/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: continue
+description: Check project status across PROJECT_SUMMARY.md, epics, and stories to determine what should be done next. Reports "All done!" if everything is complete.
+keywords:
+  - continue
+  - next
+  - proceed
+  - what's next
+  - status
+examples:
+  - "what should I do next?"
+  - "continue with the project"
+---
+
+# Continue — Pick Up the Next Work Item
+
+## Instructions
+
+1. **Check `project/PROJECT_SUMMARY.md`** — Determine if there is outstanding work at the project level.
+
+2. **Check `project/epics/`** — If the project summary is done, check if any epics have remaining work.
+
+3. **Check `project/stories/`** — If epics are done, check if any stories have remaining work.
+
+   **Important:** Always check story status within an epic even if the epic itself is marked as done.
+
+4. **If everything is complete** — Respond with: "All done! 🎉"
+
+5. **Otherwise** — Begin work on the next incomplete item.

package/skills/convert/SKILL.md

@@ -0,0 +1,124 @@
+---
+name: convert
+description: Convert JSON, JSONL, YAML, or YML dataset files to CSV format. Pass-through for files already in CSV. Flattens nested structures using dot-notation.
+keywords:
+  - convert
+  - csv
+  - json to csv
+  - yaml to csv
+  - dataset format
+examples:
+  - "convert this JSON file to CSV"
+  - "convert my dataset to CSV format"
+---
+
+# Convert — Dataset File Converter
+
+## What It Does
+
+`/convert` takes a dataset file in JSON, JSONL, YAML, or YML format and outputs a clean CSV file ready for use in `/train` jobs.
+
+- **Auto-detects** the input format from the file extension
+- **Flattens** nested objects using dot-notation (e.g. `{"user": {"age": 30}}` → column `user.age`)
+- **Pass-through**: if the input is already `.csv`, it is returned unchanged
+- **Warns** if the top-level structure is an object `{}` instead of an array `[]`, and asks for confirmation before converting
+
+Output is written to the **same directory** as the input file, with a `.csv` extension.
+
+---
+
+## Invocation
+
+```bash
+python skills/convert/convert_cli.py <path-to-file>
+```
+
+Or, when invoked through the Copilot CLI:
+
+```
+/convert <path-to-file>
+```
+
+---
+
+## Supported Formats
+
+| Extension     | Description                                      |
+|---------------|--------------------------------------------------|
+| `.json`       | JSON array `[{...}, ...]` or object `{...}`      |
+| `.jsonl`      | JSON Lines — one JSON object per line            |
+| `.yaml`/`.yml`| YAML array of records or mapping                 |
+| `.csv`        | Already CSV — returned as-is (no conversion)     |
+
+---
+
+## Examples
+
+### JSON array → CSV
+
+```bash
+python skills/convert/convert_cli.py data/train.json
+# Output: data/train.csv
+```
+
+### JSONL with nested structures → CSV
+
+Input `data/train.jsonl`:
+```
+{"id": 1, "user": {"name": "Alice", "age": 30}, "label": "pos"}
+{"id": 2, "user": {"name": "Bob",   "age": 25}, "label": "neg"}
+```
+
+Output `data/train.csv`:
+```
+id,user.name,user.age,label
+1,Alice,30,pos
+2,Bob,25,neg
+```
+
+### YAML → CSV
+
+```bash
+python skills/convert/convert_cli.py data/train.yaml
+# Output: data/train.csv
+```
+
+### CSV pass-through
+
+```bash
+python skills/convert/convert_cli.py data/train.csv
+# ✅ Input is already CSV — no conversion needed: /path/to/data/train.csv
+```
+
+### JSON object (top-level `{}`)
+
+When the file's top-level structure is an object rather than an array, the tool warns:
+
+```
+⚠️  Warning: 'config.json' has a top-level object ({...}), not an array ([...]).
+   The tool will create a single-row CSV where each top-level key becomes a column.
+   Proceed? [y/N]
+```
+
+---
+
+## Dot-Notation Flattening
+
+Nested dicts are flattened recursively:
+
+| Input JSON                              | CSV column     | Value |
+|-----------------------------------------|----------------|-------|
+| `{"user": {"name": "Alice"}}`           | `user.name`    | Alice |
+| `{"user": {"address": {"city": "NYC"}}}` | `user.address.city` | NYC |
+| `{"tags": ["ml", "nlp"]}`               | `tags`         | `["ml", "nlp"]` (JSON string) |
+
+Lists nested within records are preserved as JSON strings.
+
+---
+
+## Notes
+
+- Requires `pyyaml` for YAML/YML support: `pip install pyyaml`
+- Standard library only for JSON and JSONL (no extra dependencies)
+- Columns are ordered by first appearance across all records
+- Records missing a key will have an empty cell in that column

package/skills/convert/convert_cli.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+"""
+convert_cli.py — Dataset file converter for ML training jobs.
+
+Usage:
+    python convert_cli.py <path-to-file>
+
+Supported input formats:
+    .json   — JSON array of records (or object, with confirmation)
+    .jsonl  — JSON Lines (one record per line)
+    .yaml   — YAML array of records (or object, with confirmation)
+    .yml    — same as .yaml
+    .csv    — pass-through (returned as-is, no conversion)
+
+Output:
+    Written to the same directory as the input file with a .csv extension.
+    e.g.  data/train.json  →  data/train.csv
+"""
+import csv
+import json
+import sys
+from pathlib import Path
+
+try:
+    import yaml
+    _YAML_AVAILABLE = True
+except ImportError:
+    _YAML_AVAILABLE = False
+
+SUPPORTED_EXTENSIONS = {".json", ".jsonl", ".yaml", ".yml", ".csv"}
+
+
+# ---------------------------------------------------------------------------
+# Flattening
+# ---------------------------------------------------------------------------
+
+def _flatten(record, prefix=""):
+    """
+    Recursively flatten a nested dict using dot-notation keys.
+    Non-dict values (including lists) are kept as-is (lists become JSON strings).
+    """
+    out = {}
+    for k, v in record.items():
+        full_key = f"{prefix}.{k}" if prefix else k
+        if isinstance(v, dict):
+            out.update(_flatten(v, full_key))
+        elif isinstance(v, list):
+            out[full_key] = json.dumps(v)
+        else:
+            out[full_key] = v
+    return out
+
+
+def flatten_records(records):
+    """Flatten a list of dicts. Returns a list of flat dicts."""
+    return [_flatten(r) if isinstance(r, dict) else {"value": r} for r in records]
+
+
+# ---------------------------------------------------------------------------
+# Loaders
+# ---------------------------------------------------------------------------
+
+def load_json(path):
+    with open(path, encoding="utf-8") as f:
+        data = json.load(f)
+    return data
+
+
+def load_jsonl(path):
+    records = []
+    with open(path, encoding="utf-8") as f:
+        for lineno, line in enumerate(f, 1):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                records.append(json.loads(line))
+            except json.JSONDecodeError as e:
+                print(f"⚠️  Skipping line {lineno} — JSON parse error: {e}")
+    return records
+
+
+def load_yaml(path):
+    if not _YAML_AVAILABLE:
+        print("❌ PyYAML is not installed. Install it with: pip install pyyaml")
+        sys.exit(1)
+    with open(path, encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+    return data
+
+
+# ---------------------------------------------------------------------------
+# Top-level structure sniff + normalisation
+# ---------------------------------------------------------------------------
+
+def _confirm_object_conversion(path, yes=False):
+    """
+    Warn the user that the top-level structure is a dict (not a list),
+    and ask whether to proceed by treating each top-level key as a column.
+    Returns True to proceed, False to abort.
+    When yes=True, auto-confirms without prompting (for non-interactive use).
+    """
+    print(f"\n⚠️  Warning: '{path.name}' has a top-level object ({{...}}), not an array ([...]).")
+    print("   The tool will create a single-row CSV where each top-level key becomes a column.")
+    if yes:
+        print("   Auto-confirming (--yes flag set).")
+        return True
+    try:
+        answer = input("   Proceed? [y/N] ").strip().lower()
+    except EOFError:
+        answer = "n"
+    return answer in ("y", "yes")
+
+
+def normalise_to_records(data, path, yes=False):
+    """
+    Ensure data is a list of dicts.
+    - list  → used directly
+    - dict  → warn + confirm, then wrap as [data]
+    - other → error
+    When yes=True, dict top-level is auto-confirmed.
+    """
+    if isinstance(data, list):
+        return data
+    if isinstance(data, dict):
+        if not _confirm_object_conversion(path, yes=yes):
+            print("❌ Conversion aborted by user.")
+            sys.exit(0)
+        return [data]
+    print(f"❌ Unsupported top-level type '{type(data).__name__}'. Expected a list or dict.")
+    sys.exit(1)
+
+
+# ---------------------------------------------------------------------------
+# Writer
+# ---------------------------------------------------------------------------
+
+def write_csv(records, output_path):
+    """Write a list of flat dicts to a CSV file."""
+    if not records:
+        print(f"⚠️  No records to write — creating empty CSV at {output_path}")
+        output_path.write_text("")
+        return
+
+    # Build a unified ordered fieldset (preserving first-seen order)
+    fieldnames = list(dict.fromkeys(k for r in records for k in r))
+
+    with open(output_path, "w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames, extrasaction="ignore")
+        writer.writeheader()
+        writer.writerows(records)
+
+    print(f"✅ Converted → {output_path}  ({len(records)} row{'s' if len(records) != 1 else ''})")
+
+
+# ---------------------------------------------------------------------------
+# Main conversion entry point
+# ---------------------------------------------------------------------------
+
+def convert(input_path_str, yes=False):
+    """
+    Convert the given file to CSV.
+    Returns the output path (str), or the input path for .csv pass-through.
+    When yes=True, object top-level confirmation is auto-accepted.
+    """
+    path = Path(input_path_str).resolve()
+
+    if not path.exists():
+        print(f"❌ File not found: {path}")
+        sys.exit(1)
+
+    ext = path.suffix.lower()
+
+    if ext not in SUPPORTED_EXTENSIONS:
+        print(f"❌ Unsupported file extension '{ext}'.")
+        print(f"   Supported: {', '.join(sorted(SUPPORTED_EXTENSIONS))}")
+        sys.exit(1)
+
+    # Pass-through for CSV
+    if ext == ".csv":
+        print(f"✅ Input is already CSV — no conversion needed: {path}")
+        return str(path)
+
+    # Load data based on format
+    if ext == ".json":
+        data = load_json(path)
+    elif ext == ".jsonl":
+        data = load_jsonl(path)
+        # JSONL is already a list of records
+        records = flatten_records(normalise_to_records(data, path, yes=yes))
+        output_path = path.with_suffix(".csv")
+        write_csv(records, output_path)
+        return str(output_path)
+    elif ext in (".yaml", ".yml"):
+        data = load_yaml(path)
+    else:
+        print(f"❌ Extension '{ext}' reached conversion without a handler — this is a bug.")
+        sys.exit(1)
+
+    records = flatten_records(normalise_to_records(data, path, yes=yes))
+    output_path = path.with_suffix(".csv")
+    write_csv(records, output_path)
+    return str(output_path)
+
+
+# ---------------------------------------------------------------------------
+# CLI entry point
+# ---------------------------------------------------------------------------
+
+def main():
+    args = [a for a in sys.argv[1:] if a not in ("-h", "--help")]
+    help_requested = "-h" in sys.argv or "--help" in sys.argv
+    yes = "--yes" in args or "--no-confirm" in args
+    file_args = [a for a in args if not a.startswith("--")]
+
+    if help_requested or len(file_args) != 1:
+        print("Usage: python convert_cli.py <path-to-file> [--yes]")
+        print()
+        print("Supported formats: .json, .jsonl, .yaml, .yml, .csv")
+        print()
+        print("Options:")
+        print("  --yes, --no-confirm   Auto-confirm object-to-CSV conversion (non-interactive)")
+        print()
+        print("Examples:")
+        print("  python convert_cli.py data/train.json")
+        print("  python convert_cli.py data/train.jsonl --yes")
+        print("  python convert_cli.py data/train.yaml")
+        print("  python convert_cli.py data/train.csv   # pass-through")
+        sys.exit(0 if help_requested else 1)
+
+    convert(file_args[0], yes=yes)
+
+
+if __name__ == "__main__":
+    main()

package/skills/convert/tests/sample.csv

@@ -0,0 +1,4 @@
+id,text,meta.source,meta.lang,label
+1,The movie was great,twitter,en,positive
+2,Terrible experience,reddit,en,negative
+3,Pretty average overall,twitter,en,neutral

package/skills/convert/tests/sample.json

@@ -0,0 +1,5 @@
+[
+  {"id": 1, "user": {"name": "Alice", "age": 30}, "label": "positive", "tags": ["ml", "nlp"]},
+  {"id": 2, "user": {"name": "Bob",   "age": 25}, "label": "negative", "tags": ["cv"]},
+  {"id": 3, "user": {"name": "Carol", "age": 35}, "label": "positive", "tags": []}
+]

package/skills/convert/tests/sample.jsonl

@@ -0,0 +1,3 @@
+{"id": 1, "user": {"name": "Alice", "age": 30}, "score": 0.95, "label": "pos"}
+{"id": 2, "user": {"name": "Bob", "age": 25}, "score": 0.72, "label": "neg"}
+{"id": 3, "user": {"name": "Carol", "age": 35}, "score": 0.88, "label": "pos", "extra": {"source": "web"}}

package/skills/convert/tests/sample.yaml

@@ -0,0 +1,18 @@
+- id: 1
+  text: "The movie was great"
+  meta:
+    source: twitter
+    lang: en
+  label: positive
+- id: 2
+  text: "Terrible experience"
+  meta:
+    source: reddit
+    lang: en
+  label: negative
+- id: 3
+  text: "Pretty average overall"
+  meta:
+    source: twitter
+    lang: en
+  label: neutral

package/skills/convert/tests/sample_obj.csv

@@ -0,0 +1,2 @@
+name,age,address.city,address.zip,active
+Alice,30,New York,10001,True

package/skills/convert/tests/sample_obj.json

@@ -0,0 +1,9 @@
+{
+  "name": "Alice",
+  "age": 30,
+  "address": {
+    "city": "New York",
+    "zip": "10001"
+  },
+  "active": true
+}

package/skills/deep-dive/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: deep-dive
+description: >
+  Multi-phase investigation workflow. The scrum-master orchestrates information
+  gathering, interactive brainstorming, critical scrutiny, and solution assessment
+  to produce a refined, well-considered output document. Use when a request needs
+  thorough analysis before committing to a plan. Triggers on phrases like
+  "deep dive", "investigate thoroughly", "think this through properly",
+  "analyze this in depth", or "I want a thorough analysis of".
+metadata:
+  prefered_agent: scrum_master
+keywords:
+  - "deep dive"
+  - "investigate"
+  - "analyze thoroughly"
+  - "think through"
+examples:
+  - "deep dive on this idea"
+  - "let's think through this properly"
+  - "I want a thorough analysis of this feature"
+  - "investigate this proposal in depth"
+---
+
+# /deep-dive — Deep Investigation Workflow
+
+## Overview
+
+A multi-phase workflow that takes a user's request through structured investigation,
+collaborative brainstorming, critical scrutiny, and optional solution assessment —
+producing a refined, saved output document.
+
+### Modes
+
+| Mode | Pipeline | When to use |
+|------|----------|-------------|
+| `explore` | Info gathering → Brainstorm → Save | Idea is clear, just needs structure |
+| `challenge` | + Scrutiny review → Amend → Save | Default — most requests |
+| `resolve` | + Solution assessment → Amend → Save | Known problems need concrete solutions |
+
+**Default mode: `challenge`**
+
+---
+
+## Instructions
+
+### Step 1 — Receive the Request
+
+Accept the user's mission, issue, or idea as the **request**. Note it clearly before proceeding.
+
+---
+
+### Step 2 — Select Mode
+
+If the user has not specified a mode, ask:
+
+> "How deep should we go?"
+> 1. **Explore** — Brainstorm only
+> 2. **Challenge** — Brainstorm + critical scrutiny *(default)*
+> 3. **Resolve** — Full pipeline with solution assessment
+
+If the user is in a hurry or it's obvious from context, default to `challenge` without asking.
+
+---
+
+### Step 3 — Information Gathering (Judgment Call)
+
+Before brainstorming, assess whether sufficient context exists to proceed productively.
+
+- Check `project/documentation/examples/` for related prior work or descriptions
+- Consider invoking `/examplify` if a concept in the request needs clarification
+- Ask the user directly if a critical piece of context is missing
+
+**Default: proceed.** Do not over-investigate. The brainstorm step will surface gaps naturally. Move on unless something fundamental is clearly missing.
+
+---
+
+### Step 4 — Interactive Brainstorm
+
+Invoke `/brainstorm` with the request and any context gathered in Step 3.
+
+This is an **interactive session** — the user participates actively. Ask focused questions,
+challenge assumptions, and explore the design space together.
+
+When the user signals they are satisfied with the brainstorm output, **capture the full brainstorm result** as the working document and proceed.
+
+---
+
+### Step 5 — Scrutiny Review (`challenge` and `resolve` modes)
+
+Summon the `scrutiny-agent` (`agents/scrutiny-agent.md`) with the brainstorm output as input.
+
+The scrutiny agent will:
+- Produce a structured critical assessment (assumptions, key questions, risks, strengths)
+- Save it to `./scrutiny-<slug>.md`
+- Return the assessment to the scrum-master
+
+**Escalation threshold is low.** After reading the scrutiny output, escalate to Step 6 if any of the following are true:
+- Any risk is rated **Med** or **High** severity
+- Any key question remains unanswered and is not trivial
+- Any core assumption is directly challenged without a clear resolution
+
+If none of the above apply and the mode is `challenge`, skip Step 6 and proceed to Step 7.
+
+---
+
+### Step 6 — Solution Assessment (`resolve` mode, or escalated from `challenge`)
+
+Summon the `solution-assessor` (`agents/solution-assessor.md`) in **Mode B (chained)** —
+pass the full scrutiny output as input.
+
+The solution assessor will:
+- Derive all problems from the scrutiny output
+- Assess candidate solutions with effort, risk, and viability
+- Save the assessment to `./solution-assessment-<slug>.md`
+- Return the full assessment to the scrum-master
+
+---
+
+### Step 7 — Amend the Brainstorm Output
+
+The scrum-master **amends** the captured brainstorm document — does not replace it.
+
+Append a `## 🔍 Deep Dive Synthesis` section at the end of the brainstorm document containing:
+
+```markdown
+## 🔍 Deep Dive Synthesis
+
+### Scrutiny Findings
+[Brief summary of critical concerns, key questions, and risks identified]
+→ Full assessment: `./scrutiny-<slug>.md`
+
+### Solution Paths *(if applicable)*
+[Brief summary of recommended solution paths and estimated effort]
+→ Full assessment: `./solution-assessment-<slug>.md`
+
+### Open Decisions
+[Any unresolved questions or choices the user must make before proceeding]
+```
+
+Keep each section **concise** — these are signposts to the full documents, not rewrites of them.
+
+---
+
+### Step 8 — Save Output
+
+Determine the correct output directory based on content:
+
+| Directory | When to use |
+|-----------|-------------|
+| `project/documentation/plans/` | Result can directly seed one or more Epics and/or Stories |
+| `project/documentation/examples/` | Result is primarily descriptive or explanatory in nature |
+| `project/documentation/summaries/` | Everything else |
+
+Save the amended brainstorm document as `<slug>.md` in the chosen directory.
+Also move any scrutiny/solution-assessment files from the working directory into the same directory for co-location.
+
+Inform the user of all saved file paths.
+
+---
+
+### Step 9 — Offer Next Steps
+
+Ask the user:
+
+> "Would you like to commit this to the board?"
+> 1. **Yes** — proceed with `/todo` to create board items from the output
+> 2. **No** — close the deep-dive session