nlos 1.0.0

package/projects/README.md

@@ -0,0 +1,146 @@
+---
+type: document
+last_updated: 2025-12-03
+description: |
+  Directory overview and organization guide for all project folders in the Capturebox workspace. Summarizes folder structure, system definitions, archival process, natural language navigation patterns, and current status of principal active project systems.
+---
+
+# Projects Directory
+
+## Structure
+
+### active/
+
+Work in progress — artifacts being actively developed.
+
+- **active/cisco/** — Cisco work projects, drafts, analyses, decks
+- **active/personal/** — Personal tasks, side projects, experiments
+
+### systems/
+
+Reusable systems and their operating files. These are frameworks/tools that generate artifacts.
+
+| System                     | Purpose                                                              | Command(s)                          |
+|----------------------------|----------------------------------------------------------------------|-------------------------------------|
+| **design-pipeline**        | Tracker for UX design work — gates, artifacts, reminders, progress   | `/dp`, `/dp-status`, `/dp-gate`     |
+| **design-thinking-system** | Constraint-based design analysis, XDR principles evaluation          | `/evaluate-design`, `/design-spec`  |
+| **feature-forge**          | Orchestrator experiment for full automation (laboratory status)      | `/feature-forge`                    |
+| **hype-system**            | Context-aware creative momentum and forward-looking observations     | `/hype`                             |
+| **journalpad-system**      | Interactive journaling tool with adaptive Q/A and explore flavors    | `/journalpad`                       |
+| **lateral-os**             | LSP Operating System — intelligence layer for ideation               | `/lsp-*` commands                   |
+| **natural-language-os**    | Book project: "LLMs as substrate for domain-specific operating systems" | — book                           |
+| **persona-as-agent**       | Security persona agents (SAM, REMI, ALEX, KIT, NIK) for HCD process  | `/persona-system`, `/persona-adapt` |
+| **problem-solver-system**  | Lightweight connector aggregating problem-solving techniques from lateral-os, design-thinking-system, and signal-to-action | `/problem-solver` |
+| **skills-engine-system**   | Define, store, and route reusable skills as low-flavor background capabilities | `/skills` |
+| **self-writer-system**     | Performance reviews, personal reflection, growth journaling          | `/perf-writer`, `/self-reflect`     |
+| **signal-to-action**       | Transform unstructured input into structured artifacts via recipes   | `/run-recipe`                       |
+| **ux-blog-system**         | 6-phase systematic blog post creation                                | `/ux-blog`                          |
+| **ux-writer-system**       | Context-aware UI copy generation (tooltips, microcopy, voice)        | `/ux-writer`, `/ux-voice-check`     |
+| **visual-design-system**   | Gestalt-based perceptual design principles, constraints, and framework evaluation | —                    |
+
+### tools/
+
+Standalone utilities and helpers.
+
+- **prompt-maker-for-ai-assistant/** — Example build prompt for UI components (see `/prompt-maker-ui` command)
+
+---
+
+## Natural Language Guidance
+
+| Query                          | Path                                    |
+|--------------------------------|-----------------------------------------|
+| "Show me active work"          | `active/`                               |
+| "Show me Cisco projects"       | `active/cisco/`                         |
+| "Show me personal projects"    | `active/personal/`                      |
+| "What systems are available?"  | `systems/`                              |
+| "System outputs go where?"     | `active/` (drafts) or `docs/` (final)   |
+
+---
+
+## Archive Pattern
+
+When a project is complete:
+
+- Move from `active/cisco/` → `archive/projects/cisco/`
+- Move from `active/personal/` → `archive/projects/personal/`
+
+---
+
+## Current Active Projects
+---
+
+## System Status
+
+| System                 | Status                    | Last Updated |
+|------------------------|---------------------------|--------------|
+| design-pipeline        | Experimental/Pursuing     | 2025-12-20   |
+| design-thinking-system | Active                    | 2025-11-29   |
+| feature-forge          | Experimental/Laboratory   | 2025-12-20   |
+| hype-system            | Active                    | 2025-11-30   |
+| journalpad-system      | Active                    | 2025-12-19   |
+| lateral-os             | Operational               | 2025-11-28   |
+| natural-language-os    | First Draft               | 2025-12-01   |
+| persona-as-agent       | Production                | 2025-11-29   |
+| self-writer-system     | Active                    | 2025-11-27   |
+| signal-to-action       | Active (v2 testing)       | 2025-11-30   |
+| ux-blog-system         | Active                    | 2025-11-25   |
+| ux-writer-system       | Active                    | 2025-11-24   |
+| visual-design-system   | Active                    | 2025-12-09   |
+
+---
+
+## Philosophy
+
+The systems in this directory share a common architecture: **human-in-the-loop epistemic control**.
+
+These are not automation engines. They are cognitive accelerators.
+
+### The Inversion
+
+The system doesn't produce answers for the human. The human works to produce their own understanding *through* using the system.
+
+This inverts the typical AI framing where the model is the intelligent agent and the human is the beneficiary. Here, the human is the intelligent agent. The model runs the operating system.
+
+### How It Works
+
+Each system follows a recursive pattern:
+
+1. **Take input** — unstructured material, constraints, context
+2. **Transform it** — into structured scaffolds, interpretable artifacts
+3. **Hand it back** — for interrogation, reshaping, redirection
+4. **Use human shaping** — as the next instruction
+
+The system is not "working for" the operator. The operator is working *through* the system.
+
+### Why This Matters
+
+Understanding emerges through recursive interaction. Each pass through the system is a learning cycle:
+
+| Interaction | What the Human Gains |
+|-------------|----------------------|
+| Reading outputs | Seeing material reflected in new structure |
+| Interpreting meaning | Connecting system transforms to real intent |
+| Refining direction | Clarifying and focusing what actually needs to be known |
+| Reshaping artifacts | Discovering gaps in topic understanding |
+| Adjusting protocols | Encoding insight into future iterations |
+
+The system doesn't need to be "right" — it needs to be *useful for thinking*. Every interaction surfaces something: a connection you missed, a framing you hadn't considered, a question you didn't know to ask.
+
+The human learns. The system accelerates the learning.
+
+What emerges is a hybrid computational model:
+
+> The machine transforms information.
+> The human transforms the system.
+> And the system transforms the human.
+
+### The Doctrine
+
+A Natural Language Operating System is a structured expert companion, but not the final authority; it is a structured way of thinking interactively with the machine. The model transforms your inputs, and you use those transforms to see more clearly, decide more deliberately, and learn faster.
+
+> **Definition**: A Natural Language Operating System is a human-directed cognitive instrument that enables learning, reasoning, and decision-making through structured machine-mediated iteration.
+
+---
+
+*Last updated: 2025-12-20*

package/scripts/generate-kernel-payload.py

@@ -0,0 +1,339 @@
+#!/usr/bin/env python3
+"""
+generate-kernel-payload.py - Generate portable NL-OS kernel payloads
+
+Creates standalone files that can be fed to ANY LLM as system prompt/context.
+The generated payload allows any capable model to "boot" into Capturebox NL-OS mode.
+
+Usage:
+    python3 scripts/generate-kernel-payload.py [options]
+
+Options:
+    --tier TIER       Payload tier: mandatory, lazy, full (default: mandatory)
+    --format FORMAT   Output format: markdown, json, text (default: markdown)
+    --output PATH     Output file path (default: portable/kernel-payload.md)
+    --all             Generate all tiers and formats
+    --verify          Verify all source files exist
+    --tokens          Show token estimates only, don't generate
+
+Examples:
+    python3 scripts/generate-kernel-payload.py                        # Default payload
+    python3 scripts/generate-kernel-payload.py --tier full            # Full kernel
+    python3 scripts/generate-kernel-payload.py --format json          # JSON for APIs
+    python3 scripts/generate-kernel-payload.py --all                  # All variants
+    python3 scripts/generate-kernel-payload.py --verify               # Verify files
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from datetime import datetime
+from typing import Optional
+
+# Resolve capturebox root
+SCRIPT_DIR = Path(__file__).parent
+CAPTUREBOX_ROOT = SCRIPT_DIR.parent
+
+# File definitions with token estimates (based on ~4 chars per token)
+KERNEL_FILES = {
+    'mandatory': [
+        ('memory.md', 4600),
+        ('AGENTS.md', 1200),
+        ('axioms.yaml', 4800),
+    ],
+    'lazy': [
+        ('personalities.md', 3600),
+        ('.cursor/commands/COMMAND-MAP.md', 1350),
+    ],
+    'extended': [
+        ('projects/README.md', 1000),
+        ('KERNEL.yaml', 500),
+    ],
+}
+
+
+def read_file(path: Path) -> str:
+    """Read file contents, return placeholder if missing."""
+    full_path = CAPTUREBOX_ROOT / path
+    if full_path.exists():
+        return full_path.read_text()
+    return f"# File not found: {path}\n"
+
+
+def verify_files() -> bool:
+    """Verify all kernel files exist."""
+    all_exist = True
+
+    print("Verifying kernel files...")
+    print()
+
+    for tier_name, files in KERNEL_FILES.items():
+        print(f"  {tier_name.upper()} tier:")
+        for filename, tokens in files:
+            full_path = CAPTUREBOX_ROOT / filename
+            exists = full_path.exists()
+            status = "[x]" if exists else "[ ]"
+            size = f"({full_path.stat().st_size:,} bytes)" if exists else "(MISSING)"
+            print(f"    {status} {filename} {size}")
+            if not exists and tier_name == 'mandatory':
+                all_exist = False
+        print()
+
+    return all_exist
+
+
+def estimate_tokens(tier: str = 'mandatory') -> dict:
+    """Calculate token estimates for a tier."""
+    files_to_include = KERNEL_FILES['mandatory'].copy()
+
+    if tier in ('lazy', 'full'):
+        files_to_include.extend(KERNEL_FILES['lazy'])
+    if tier == 'full':
+        files_to_include.extend(KERNEL_FILES['extended'])
+
+    total_tokens = sum(tokens for _, tokens in files_to_include)
+
+    return {
+        'tier': tier,
+        'file_count': len(files_to_include),
+        'estimated_tokens': total_tokens,
+        'files': [(f, t) for f, t in files_to_include],
+    }
+
+
+def generate_payload(tier: str = 'mandatory', format: str = 'markdown') -> str:
+    """Generate kernel payload for specified tier and format."""
+
+    files_to_load = KERNEL_FILES['mandatory'].copy()
+    if tier in ('lazy', 'full'):
+        files_to_load.extend(KERNEL_FILES['lazy'])
+    if tier == 'full':
+        files_to_load.extend(KERNEL_FILES['extended'])
+
+    # Load file contents
+    sections = []
+    total_tokens = 0
+
+    for filename, tokens in files_to_load:
+        content = read_file(Path(filename))
+        actual_tokens = len(content) // 4  # Rough estimate
+        sections.append({
+            'file': filename,
+            'content': content,
+            'estimated_tokens': tokens,
+            'actual_chars': len(content),
+        })
+        total_tokens += actual_tokens
+
+    # Format output
+    if format == 'json':
+        return json.dumps({
+            'metadata': {
+                'generated': datetime.now().isoformat(),
+                'generator': 'generate-kernel-payload.py',
+                'tier': tier,
+                'total_estimated_tokens': total_tokens,
+                'file_count': len(sections),
+            },
+            'instructions': (
+                "Feed this payload to any LLM as system prompt or context. "
+                "The model will boot into Capturebox NL-OS mode. "
+                "After loading, the model should acknowledge: "
+                "'Kernel loaded. Ready for capturebox operations.'"
+            ),
+            'files': [
+                {
+                    'filename': s['file'],
+                    'content': s['content'],
+                }
+                for s in sections
+            ],
+        }, indent=2, ensure_ascii=False)
+
+    elif format == 'text':
+        # Plain concatenation for simple use
+        return '\n\n'.join([s['content'] for s in sections])
+
+    else:  # markdown (default)
+        header = f"""# Capturebox NL-OS Kernel Payload
+
+**Generated**: {datetime.now().strftime('%Y-%m-%d %H:%M')}
+**Tier**: {tier}
+**Estimated tokens**: ~{total_tokens:,}
+**Files**: {len(sections)}
+
+---
+
+## How to Use This Payload
+
+Feed this entire file as system prompt or context to any capable LLM.
+The LLM will "boot" into Capturebox NL-OS mode.
+
+### Supported Runtimes:
+- Claude Code / Claude API
+- Cursor IDE
+- Ollama (any model)
+- llama.cpp
+- LM Studio
+- OpenAI-compatible APIs
+- Any LLM with system prompt capability
+
+### After Loading
+
+The model should acknowledge: **"Kernel loaded. Ready for capturebox operations."**
+
+### Quick Start
+
+**Ollama:**
+```bash
+ollama run qwen2.5:3b --system "$(cat portable/kernel-payload.md)"
+```
+
+**LM Studio:**
+1. Open LM Studio
+2. Paste this file's contents into System Prompt
+3. Start chatting
+
+**API (OpenAI-compatible):**
+```python
+messages = [
+    {{"role": "system", "content": open("portable/kernel-payload.md").read()}},
+    {{"role": "user", "content": "Acknowledge kernel boot."}}
+]
+```
+
+---
+
+# KERNEL CONTEXT BEGINS
+
+"""
+
+        body_parts = []
+        for s in sections:
+            body_parts.append(f"""---
+
+## {s['file']}
+
+{s['content']}
+""")
+
+        footer = """
+---
+
+# KERNEL CONTEXT ENDS
+
+After reading the above kernel context, acknowledge with:
+"Kernel loaded. Ready for capturebox operations."
+"""
+
+        return header + '\n'.join(body_parts) + footer
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Generate portable NL-OS kernel payloads',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__
+    )
+    parser.add_argument(
+        '--tier',
+        choices=['mandatory', 'lazy', 'full'],
+        default='mandatory',
+        help='Payload tier (default: mandatory)'
+    )
+    parser.add_argument(
+        '--format',
+        choices=['markdown', 'json', 'text'],
+        default='markdown',
+        help='Output format (default: markdown)'
+    )
+    parser.add_argument(
+        '--output',
+        type=Path,
+        help='Output file path (default: portable/kernel-payload.md)'
+    )
+    parser.add_argument(
+        '--all',
+        action='store_true',
+        help='Generate all tiers and formats'
+    )
+    parser.add_argument(
+        '--verify',
+        action='store_true',
+        help='Verify all source files exist'
+    )
+    parser.add_argument(
+        '--tokens',
+        action='store_true',
+        help='Show token estimates only'
+    )
+
+    args = parser.parse_args()
+
+    # Verify mode
+    if args.verify:
+        success = verify_files()
+        sys.exit(0 if success else 1)
+
+    # Token estimate mode
+    if args.tokens:
+        for tier in ['mandatory', 'lazy', 'full']:
+            info = estimate_tokens(tier)
+            print(f"\n{tier.upper()} tier: ~{info['estimated_tokens']:,} tokens")
+            for filename, tokens in info['files']:
+                print(f"  - {filename}: ~{tokens:,}")
+        sys.exit(0)
+
+    # Ensure output directory exists
+    output_dir = CAPTUREBOX_ROOT / 'portable'
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Generate all mode
+    if args.all:
+        generated = []
+
+        # Generate all combinations
+        for tier in ['mandatory', 'full']:
+            for fmt in ['markdown', 'json']:
+                suffix = '' if tier == 'mandatory' else f'-{tier}'
+                ext = 'md' if fmt == 'markdown' else fmt
+                output_path = output_dir / f'kernel-payload{suffix}.{ext}'
+
+                payload = generate_payload(tier=tier, format=fmt)
+                output_path.write_text(payload)
+
+                info = estimate_tokens(tier)
+                generated.append({
+                    'file': output_path.name,
+                    'tier': tier,
+                    'format': fmt,
+                    'tokens': info['estimated_tokens'],
+                })
+                print(f"Generated: {output_path}")
+
+        print(f"\nGenerated {len(generated)} payload files in {output_dir}/")
+        return
+
+    # Single file generation
+    if args.output:
+        output_path = args.output
+    else:
+        suffix = '' if args.tier == 'mandatory' else f'-{args.tier}'
+        ext = 'md' if args.format == 'markdown' else args.format
+        output_path = output_dir / f'kernel-payload{suffix}.{ext}'
+
+    # Generate payload
+    payload = generate_payload(tier=args.tier, format=args.format)
+
+    # Write output
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(payload)
+
+    info = estimate_tokens(args.tier)
+    print(f"Generated {args.tier} kernel payload: {output_path}")
+    print(f"Estimated tokens: ~{info['estimated_tokens']:,}")
+
+
+if __name__ == '__main__':
+    main()

package/scripts/kernel-boot-llama-cpp.sh

@@ -0,0 +1,192 @@
+#!/usr/bin/env bash
+# kernel-boot-llama-cpp.sh - Boot NL-OS kernel via llama.cpp
+#
+# Usage: ./scripts/kernel-boot-llama-cpp.sh [--model PATH] [--full] [--output FILE]
+#
+# Generates a prompt file from kernel files for use with llama.cpp CLI.
+# You can then run: llama-cli -m model.gguf -f prompt.txt --interactive
+#
+# Options:
+#   --model PATH     Path to GGUF model file (optional, for direct launch)
+#   --full           Load full tier including personalities and command map
+#   --output FILE    Output prompt file (default: /tmp/capturebox-kernel-prompt.txt)
+#   --ctx-size N     Context size in tokens (default: 16384)
+#   --launch         Launch llama-cli directly (requires --model)
+#   --help           Show this help message
+#
+# Examples:
+#   ./scripts/kernel-boot-llama-cpp.sh                              # Generate prompt file
+#   ./scripts/kernel-boot-llama-cpp.sh --full                       # Full kernel context
+#   ./scripts/kernel-boot-llama-cpp.sh --output ~/kernel.txt        # Custom output path
+#   ./scripts/kernel-boot-llama-cpp.sh --model ~/llama3.gguf --launch  # Direct launch
+
+set -euo pipefail
+
+# Resolve capturebox root directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CAPTUREBOX_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+# Defaults
+MODEL_PATH=""
+FULL_BOOT=false
+OUTPUT_FILE="/tmp/capturebox-kernel-prompt.txt"
+CTX_SIZE=16384
+LAUNCH=false
+
+# Color output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --model)
+            MODEL_PATH="$2"
+            shift 2
+            ;;
+        --full)
+            FULL_BOOT=true
+            shift
+            ;;
+        --output)
+            OUTPUT_FILE="$2"
+            shift 2
+            ;;
+        --ctx-size)
+            CTX_SIZE="$2"
+            shift 2
+            ;;
+        --launch)
+            LAUNCH=true
+            shift
+            ;;
+        --help|-h)
+            head -25 "$0" | tail -20
+            exit 0
+            ;;
+        *)
+            echo -e "${RED}Unknown option: $1${NC}"
+            echo "Use --help for usage information"
+            exit 1
+            ;;
+    esac
+done
+
+# Verify required files exist
+echo -e "${BLUE}Verifying kernel files...${NC}"
+
+MANDATORY_FILES=(
+    "$CAPTUREBOX_ROOT/memory.md"
+    "$CAPTUREBOX_ROOT/AGENTS.md"
+    "$CAPTUREBOX_ROOT/axioms.yaml"
+)
+
+for file in "${MANDATORY_FILES[@]}"; do
+    if [[ ! -f "$file" ]]; then
+        echo -e "${RED}CRITICAL: Missing mandatory file: $file${NC}"
+        exit 1
+    fi
+done
+
+# Build kernel payload
+echo -e "${BLUE}Building kernel prompt file...${NC}"
+
+# llama.cpp prompt format with system instruction
+PROMPT="<|begin_of_text|><|start_header_id|>system<|end_header_id|>
+
+You are booting into Capturebox NL-OS. The following kernel context defines your operational parameters. Read and internalize these instructions before responding.
+
+# Capturebox NL-OS Kernel Context
+
+## memory.md (Behavioral Directives)
+
+$(cat "$CAPTUREBOX_ROOT/memory.md")
+
+---
+
+## AGENTS.md (Hard Invariants)
+
+$(cat "$CAPTUREBOX_ROOT/AGENTS.md")
+
+---
+
+## axioms.yaml (Canonical Definitions)
+
+$(cat "$CAPTUREBOX_ROOT/axioms.yaml")
+"
+
+if [[ "$FULL_BOOT" == true ]]; then
+    echo -e "${BLUE}Including lazy tier files...${NC}"
+
+    PROMPT+="
+
+---
+
+## personalities.md (Voice Presets)
+
+$(cat "$CAPTUREBOX_ROOT/personalities.md")
+
+---
+
+## COMMAND-MAP.md (Command Registry)
+
+$(cat "$CAPTUREBOX_ROOT/.cursor/commands/COMMAND-MAP.md")
+"
+fi
+
+# Close system header and add user prompt
+PROMPT+="
+
+After processing this context, acknowledge with: \"Kernel loaded. Ready for capturebox operations.\"
+
+<|eot_id|><|start_header_id|>user<|end_header_id|>
+
+Please acknowledge that you have loaded the Capturebox NL-OS kernel.<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+
+"
+
+# Calculate approximate token count
+CHAR_COUNT=${#PROMPT}
+TOKEN_ESTIMATE=$((CHAR_COUNT / 4))
+
+# Write prompt file
+echo "$PROMPT" > "$OUTPUT_FILE"
+
+echo -e "${GREEN}Kernel prompt file created: $OUTPUT_FILE${NC}"
+echo -e "${GREEN}Approximate tokens: ~$TOKEN_ESTIMATE${NC}"
+echo -e "${BLUE}Tier: $(if [[ "$FULL_BOOT" == true ]]; then echo "FULL"; else echo "MANDATORY"; fi)${NC}"
+
+# Provide usage instructions
+echo ""
+echo -e "${YELLOW}To use with llama.cpp:${NC}"
+echo "  llama-cli -m /path/to/model.gguf -f $OUTPUT_FILE --interactive --ctx-size $CTX_SIZE"
+echo ""
+echo "Or with llama-server:"
+echo "  llama-server -m /path/to/model.gguf --ctx-size $CTX_SIZE"
+echo "  Then POST the prompt content to /completion endpoint"
+
+# Launch if requested
+if [[ "$LAUNCH" == true ]]; then
+    if [[ -z "$MODEL_PATH" ]]; then
+        echo -e "${RED}Error: --launch requires --model PATH${NC}"
+        exit 1
+    fi
+
+    if [[ ! -f "$MODEL_PATH" ]]; then
+        echo -e "${RED}Error: Model file not found: $MODEL_PATH${NC}"
+        exit 1
+    fi
+
+    if ! command -v llama-cli &> /dev/null; then
+        echo -e "${RED}Error: llama-cli not found in PATH${NC}"
+        echo "Build llama.cpp and add to PATH, or use the prompt file manually"
+        exit 1
+    fi
+
+    echo ""
+    echo -e "${GREEN}Launching llama-cli with kernel context...${NC}"
+    llama-cli -m "$MODEL_PATH" -f "$OUTPUT_FILE" --interactive --ctx-size "$CTX_SIZE"
+fi