@clawos-dev/clawd 0.2.50 → 0.2.51-beta.78.2024c11

package/dist/persona-defaults/persona-researcher/.claude/skills/deep-research/schemas/evidence.schema.json

@@ -1,43 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "title": "Evidence",
-  "description": "A piece of evidence extracted from a source. evidence_id = sha256(source_id + normalized_quote + locator)[:16].",
-  "type": "object",
-  "required": ["evidence_id", "source_id", "quote", "evidence_type", "captured_at"],
-  "properties": {
-    "evidence_id": {
-      "type": "string",
-      "pattern": "^[0-9a-f]{16}$",
-      "description": "sha256(source_id + normalized_quote + locator)[:16]"
-    },
-    "source_id": {
-      "type": "string",
-      "pattern": "^[0-9a-f]{16}$",
-      "description": "References a source in sources.jsonl"
-    },
-    "retrieval_query": {
-      "type": ["string", "null"],
-      "description": "The search query or prompt that led to this evidence",
-      "default": null
-    },
-    "locator": {
-      "type": ["string", "null"],
-      "description": "Page number, section heading, URL fragment, or timestamp within the source",
-      "default": null
-    },
-    "quote": {
-      "type": "string",
-      "description": "Exact or near-exact text extracted from the source"
-    },
-    "evidence_type": {
-      "type": "string",
-      "enum": ["direct_quote", "paraphrase", "data_point", "figure_reference", "methodology"],
-      "description": "How the evidence was captured"
-    },
-    "captured_at": {
-      "type": "string",
-      "format": "date-time"
-    }
-  },
-  "additionalProperties": false
-}

package/dist/persona-defaults/persona-researcher/.claude/skills/deep-research/schemas/run_manifest.schema.json

@@ -1,97 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "title": "RunManifest",
-  "description": "Manifest for a single research run. Created at init, updated throughout.",
-  "type": "object",
-  "required": ["version", "query", "mode", "started_at", "report_dir", "artifact_paths"],
-  "properties": {
-    "version": {
-      "type": "string",
-      "const": "3.0.0"
-    },
-    "query": {
-      "type": "string",
-      "description": "Original research question"
-    },
-    "mode": {
-      "type": "string",
-      "enum": ["quick", "standard", "deep", "ultradeep"]
-    },
-    "started_at": {
-      "type": "string",
-      "format": "date-time"
-    },
-    "finished_at": {
-      "type": ["string", "null"],
-      "format": "date-time",
-      "default": null
-    },
-    "assumptions": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "required": ["assumption_id", "text", "materiality", "status"],
-        "properties": {
-          "assumption_id": {
-            "type": "string",
-            "pattern": "^asm_[0-9a-f]{8}$"
-          },
-          "text": { "type": "string" },
-          "materiality": {
-            "type": "string",
-            "enum": ["low", "medium", "high"]
-          },
-          "status": {
-            "type": "string",
-            "enum": ["implicit", "user_confirmed", "evidence_validated"]
-          }
-        },
-        "additionalProperties": false
-      },
-      "default": []
-    },
-    "provider_config": {
-      "type": "object",
-      "properties": {
-        "primary": {
-          "type": "string",
-          "description": "Primary search provider (e.g. WebSearch)"
-        },
-        "scholarly": {
-          "type": ["string", "null"],
-          "description": "Scholarly API provider if configured (e.g. openalex, semantic_scholar)"
-        }
-      },
-      "default": { "primary": "search-cli", "scholarly": null }
-    },
-    "report_dir": {
-      "type": "string",
-      "description": "Absolute path to the report directory"
-    },
-    "artifact_paths": {
-      "type": "object",
-      "required": ["sources", "evidence", "claims", "report"],
-      "properties": {
-        "sources": { "type": "string", "default": "sources.jsonl" },
-        "evidence": { "type": "string", "default": "evidence.jsonl" },
-        "claims": { "type": "string", "default": "claims.jsonl" },
-        "report": { "type": "string", "default": "report.md" }
-      },
-      "additionalProperties": false
-    },
-    "continuation": {
-      "type": ["object", "null"],
-      "description": "Populated when resuming a previous run",
-      "properties": {
-        "previous_run_manifest": { "type": "string" },
-        "resumed_at": { "type": "string", "format": "date-time" },
-        "sections_completed": {
-          "type": "array",
-          "items": { "type": "string" }
-        }
-      },
-      "default": null
-    }
-  },
-  "additionalProperties": false
-}

package/dist/persona-defaults/persona-researcher/.claude/skills/deep-research/schemas/source.schema.json

@@ -1,49 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "title": "Source",
-  "description": "A research source with stable identity. source_id = sha256(canonical_locator)[:16].",
-  "type": "object",
-  "required": ["source_id", "canonical_locator", "raw_url", "title", "source_type", "metadata_status", "registered_at"],
-  "properties": {
-    "source_id": {
-      "type": "string",
-      "pattern": "^[0-9a-f]{16}$",
-      "description": "sha256(canonical_locator)[:16] — stable across edits and continuation"
-    },
-    "canonical_locator": {
-      "type": "string",
-      "description": "Canonical identifier: doi:10.1038/..., arxiv:2305.14251, or normalized URL (scheme+host+path, no fragment/tracking params)"
-    },
-    "raw_url": {
-      "type": "string",
-      "description": "Original URL as retrieved, before normalization"
-    },
-    "title": {
-      "type": "string"
-    },
-    "authors": {
-      "type": ["array", "null"],
-      "items": { "type": "string" },
-      "default": null
-    },
-    "year": {
-      "type": ["string", "null"],
-      "default": null
-    },
-    "source_type": {
-      "type": "string",
-      "enum": ["web", "academic", "documentation", "code", "news", "government", "book"]
-    },
-    "metadata_status": {
-      "type": "string",
-      "enum": ["unverified", "doi_verified", "url_verified", "title_matched"],
-      "description": "How far metadata has been verified"
-    },
-    "registered_at": {
-      "type": "string",
-      "format": "date-time",
-      "description": "ISO 8601 timestamp when source was registered"
-    }
-  },
-  "additionalProperties": false
-}

package/dist/persona-defaults/persona-researcher/.claude/skills/deep-research/scripts/citation_manager.py

@@ -1,300 +0,0 @@
-#!/usr/bin/env python3
-"""
-Citation Manager — stable source identity and run manifest management.
-
-CLI subcommands:
-  init-run             Create run_manifest.json + empty artifact JSONL files
-  register-source      Append a source to sources.jsonl, return source_id
-  assign-display-numbers  Generate stable_id -> display_number mapping
-  export-bibliography   Render bibliography from sources.jsonl
-
-Source identity:
-  source_id = sha256(canonical_locator)[:16]
-  canonical_locator = doi:..., arxiv:..., or normalized URL
-
-All state is append-only JSONL. No mutable citation numbers in state files.
-"""
-
-import argparse
-import hashlib
-import json
-import os
-import re
-import sys
-from datetime import datetime, timezone
-from urllib.parse import urlparse, urlunparse
-
-
-# ---------------------------------------------------------------------------
-# Canonical locator normalization
-# ---------------------------------------------------------------------------
-
-DOI_RE = re.compile(r'(?:https?://(?:dx\.)?doi\.org/|doi:)(10\.\d{4,}/\S+)', re.IGNORECASE)
-ARXIV_RE = re.compile(r'(?:https?://arxiv\.org/abs/|arxiv:)(\d{4}\.\d{4,}(?:v\d+)?)', re.IGNORECASE)
-
-# URL query params that are tracking noise, not content identifiers
-TRACKING_PARAMS = frozenset([
-    'utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
-    'ref', 'source', 'fbclid', 'gclid', 'mc_cid', 'mc_eid',
-])
-
-
-def canonicalize_locator(raw_url: str) -> str:
-    """Derive a canonical locator from a raw URL or identifier string.
-
-    Priority: DOI > arXiv > normalized URL.
-    """
-    # DOI
-    m = DOI_RE.search(raw_url)
-    if m:
-        return f'doi:{m.group(1).rstrip(".")}'
-
-    # arXiv
-    m = ARXIV_RE.search(raw_url)
-    if m:
-        return f'arxiv:{m.group(1)}'
-
-    # Normalized URL: lowercase scheme+host, strip fragment and tracking params
-    parsed = urlparse(raw_url)
-    scheme = (parsed.scheme or 'https').lower()
-    host = (parsed.hostname or '').lower()
-    path = parsed.path.rstrip('/')
-    # Filter query params
-    if parsed.query:
-        pairs = []
-        for part in parsed.query.split('&'):
-            kv = part.split('=', 1)
-            if kv[0].lower() not in TRACKING_PARAMS:
-                pairs.append(part)
-        query = '&'.join(sorted(pairs))
-    else:
-        query = ''
-    return urlunparse((scheme, host, path, '', query, ''))
-
-
-def compute_source_id(canonical_locator: str) -> str:
-    """sha256(canonical_locator)[:16] hex."""
-    return hashlib.sha256(canonical_locator.encode('utf-8')).hexdigest()[:16]
-
-
-# ---------------------------------------------------------------------------
-# JSONL helpers
-# ---------------------------------------------------------------------------
-
-def append_jsonl(path: str, obj: dict) -> None:
-    with open(path, 'a') as f:
-        f.write(json.dumps(obj, ensure_ascii=False) + '\n')
-
-
-def read_jsonl(path: str) -> list[dict]:
-    rows = []
-    if not os.path.exists(path):
-        return rows
-    with open(path) as f:
-        for line in f:
-            line = line.strip()
-            if line:
-                rows.append(json.loads(line))
-    return rows
-
-
-# ---------------------------------------------------------------------------
-# Subcommands
-# ---------------------------------------------------------------------------
-
-def cmd_init_run(args: argparse.Namespace) -> None:
-    """Create run_manifest.json and empty JSONL artifact files."""
-    out_dir = os.path.abspath(args.out_dir)
-    os.makedirs(out_dir, exist_ok=True)
-
-    artifact_paths = {
-        'sources': 'sources.jsonl',
-        'evidence': 'evidence.jsonl',
-        'claims': 'claims.jsonl',
-        'report': 'report.md',
-    }
-
-    manifest = {
-        'version': '3.0.0',
-        'query': args.query or '',
-        'mode': args.mode,
-        'started_at': datetime.now(timezone.utc).isoformat(),
-        'finished_at': None,
-        'assumptions': [],
-        'provider_config': {
-            'primary': 'search-cli',
-            'scholarly': None,
-        },
-        'report_dir': out_dir,
-        'artifact_paths': artifact_paths,
-        'continuation': None,
-    }
-
-    manifest_path = os.path.join(out_dir, 'run_manifest.json')
-    with open(manifest_path, 'w') as f:
-        json.dump(manifest, f, indent=2, ensure_ascii=False)
-        f.write('\n')
-
-    # Create empty artifact files
-    for name in ('sources', 'evidence', 'claims'):
-        p = os.path.join(out_dir, artifact_paths[name])
-        if not os.path.exists(p):
-            open(p, 'w').close()
-
-    print(json.dumps({'status': 'ok', 'manifest': manifest_path, 'dir': out_dir}))
-
-
-def cmd_register_source(args: argparse.Namespace) -> None:
-    """Register a source, append to sources.jsonl, print source_id."""
-    data = json.loads(args.json)
-    raw_url = data.get('raw_url', data.get('url', ''))
-    if not raw_url:
-        print(json.dumps({'error': 'raw_url is required'}), file=sys.stderr)
-        sys.exit(1)
-
-    canonical = data.get('canonical_locator') or canonicalize_locator(raw_url)
-    source_id = compute_source_id(canonical)
-
-    sources_path = os.path.join(args.dir, 'sources.jsonl')
-
-    # Check for duplicate
-    existing = read_jsonl(sources_path)
-    for row in existing:
-        if row.get('source_id') == source_id:
-            print(json.dumps({
-                'status': 'duplicate',
-                'source_id': source_id,
-                'canonical_locator': canonical,
-            }))
-            return
-
-    source = {
-        'source_id': source_id,
-        'canonical_locator': canonical,
-        'raw_url': raw_url,
-        'title': data.get('title', ''),
-        'authors': data.get('authors'),
-        'year': data.get('year'),
-        'source_type': data.get('source_type', 'web'),
-        'metadata_status': data.get('metadata_status', 'unverified'),
-        'registered_at': datetime.now(timezone.utc).isoformat(),
-    }
-    append_jsonl(sources_path, source)
-    print(json.dumps({
-        'status': 'registered',
-        'source_id': source_id,
-        'canonical_locator': canonical,
-    }))
-
-
-def cmd_assign_display_numbers(args: argparse.Namespace) -> None:
-    """Read sources.jsonl, assign stable display numbers in registration order."""
-    sources_path = os.path.join(args.dir, 'sources.jsonl')
-    sources = read_jsonl(sources_path)
-
-    mapping = {}
-    for i, src in enumerate(sources, 1):
-        sid = src['source_id']
-        if sid not in mapping:
-            mapping[sid] = i
-
-    print(json.dumps(mapping, indent=2))
-
-
-def cmd_export_bibliography(args: argparse.Namespace) -> None:
-    """Generate bibliography from sources.jsonl."""
-    sources_path = os.path.join(args.dir, 'sources.jsonl')
-    sources = read_jsonl(sources_path)
-
-    # Deduplicate by source_id, preserve order
-    seen = set()
-    unique = []
-    for src in sources:
-        if src['source_id'] not in seen:
-            seen.add(src['source_id'])
-            unique.append(src)
-
-    style = args.style
-
-    if style == 'markdown':
-        lines = ['## Bibliography', '']
-        for i, src in enumerate(unique, 1):
-            author_str = ''
-            if src.get('authors'):
-                authors = src['authors']
-                if len(authors) == 1:
-                    author_str = f'{authors[0]}. '
-                elif len(authors) == 2:
-                    author_str = f'{authors[0]} & {authors[1]}. '
-                else:
-                    author_str = f'{authors[0]} et al. '
-
-            year_str = f'({src["year"]})' if src.get('year') else '(n.d.)'
-            title = src.get('title', 'Untitled')
-            url = src.get('raw_url', '')
-            lines.append(f'[{i}] {author_str}{year_str}. [{title}]({url})')
-        print('\n'.join(lines))
-
-    elif style == 'json':
-        out = []
-        for i, src in enumerate(unique, 1):
-            out.append({
-                'display_number': i,
-                'source_id': src['source_id'],
-                'canonical_locator': src['canonical_locator'],
-                'title': src.get('title', ''),
-                'authors': src.get('authors'),
-                'year': src.get('year'),
-                'raw_url': src.get('raw_url', ''),
-            })
-        print(json.dumps(out, indent=2, ensure_ascii=False))
-
-    else:
-        print(f'Unknown style: {style}', file=sys.stderr)
-        sys.exit(1)
-
-
-# ---------------------------------------------------------------------------
-# CLI entry point
-# ---------------------------------------------------------------------------
-
-def main() -> None:
-    parser = argparse.ArgumentParser(
-        prog='citation_manager',
-        description='Stable source identity and run manifest management for deep-research v3.0',
-    )
-    sub = parser.add_subparsers(dest='command', required=True)
-
-    # init-run
-    p_init = sub.add_parser('init-run', help='Create run manifest and empty artifact files')
-    p_init.add_argument('--out-dir', required=True, help='Output directory for the research run')
-    p_init.add_argument('--query', default='', help='Original research question')
-    p_init.add_argument('--mode', default='standard', choices=['quick', 'standard', 'deep', 'ultradeep'])
-
-    # register-source
-    p_reg = sub.add_parser('register-source', help='Register a source and return its stable ID')
-    p_reg.add_argument('--json', required=True, help='JSON object with at least raw_url and title')
-    p_reg.add_argument('--dir', required=True, help='Run directory containing sources.jsonl')
-
-    # assign-display-numbers
-    p_num = sub.add_parser('assign-display-numbers', help='Map stable source IDs to display numbers')
-    p_num.add_argument('--dir', required=True, help='Run directory containing sources.jsonl')
-
-    # export-bibliography
-    p_bib = sub.add_parser('export-bibliography', help='Generate bibliography from sources')
-    p_bib.add_argument('--dir', required=True, help='Run directory containing sources.jsonl')
-    p_bib.add_argument('--style', default='markdown', choices=['markdown', 'json'])
-
-    args = parser.parse_args()
-
-    dispatch = {
-        'init-run': cmd_init_run,
-        'register-source': cmd_register_source,
-        'assign-display-numbers': cmd_assign_display_numbers,
-        'export-bibliography': cmd_export_bibliography,
-    }
-    dispatch[args.command](args)
-
-
-if __name__ == '__main__':
-    main()

package/dist/persona-defaults/persona-researcher/.claude/skills/deep-research/scripts/evidence_store.py

@@ -1,205 +0,0 @@
-#!/usr/bin/env python3
-"""
-Evidence Store — append-only evidence persistence for deep-research v3.0.
-
-CLI subcommands:
-  init         Create empty evidence.jsonl in a run directory
-  add          Append an evidence row, return evidence_id
-  list         List evidence rows, optionally filtered by source_id
-  export       Export evidence as JSON array
-
-Evidence identity:
-  evidence_id = sha256(source_id + normalized_quote + locator)[:16]
-
-All state is append-only JSONL. Evidence is never modified after capture.
-"""
-
-import argparse
-import hashlib
-import json
-import os
-import re
-import sys
-from datetime import datetime, timezone
-
-
-# ---------------------------------------------------------------------------
-# Evidence ID computation
-# ---------------------------------------------------------------------------
-
-_WHITESPACE_RE = re.compile(r'\s+')
-
-
-def normalize_quote(quote: str) -> str:
-    """Normalize whitespace for stable hashing."""
-    return _WHITESPACE_RE.sub(' ', quote.strip()).lower()
-
-
-def compute_evidence_id(source_id: str, quote: str, locator: str | None) -> str:
-    """sha256(source_id + normalized_quote + locator)[:16] hex."""
-    payload = source_id + normalize_quote(quote) + (locator or '')
-    return hashlib.sha256(payload.encode('utf-8')).hexdigest()[:16]
-
-
-# ---------------------------------------------------------------------------
-# JSONL helpers (shared pattern with citation_manager)
-# ---------------------------------------------------------------------------
-
-def append_jsonl(path: str, obj: dict) -> None:
-    with open(path, 'a') as f:
-        f.write(json.dumps(obj, ensure_ascii=False) + '\n')
-
-
-def read_jsonl(path: str) -> list[dict]:
-    rows = []
-    if not os.path.exists(path):
-        return rows
-    with open(path) as f:
-        for line in f:
-            line = line.strip()
-            if line:
-                rows.append(json.loads(line))
-    return rows
-
-
-# ---------------------------------------------------------------------------
-# Subcommands
-# ---------------------------------------------------------------------------
-
-def cmd_init(args: argparse.Namespace) -> None:
-    """Create empty evidence.jsonl if it doesn't exist."""
-    out_dir = os.path.abspath(args.dir)
-    path = os.path.join(out_dir, 'evidence.jsonl')
-    if not os.path.exists(path):
-        os.makedirs(out_dir, exist_ok=True)
-        open(path, 'w').close()
-    print(json.dumps({'status': 'ok', 'path': path}))
-
-
-def cmd_add(args: argparse.Namespace) -> None:
-    """Append evidence row, print evidence_id."""
-    data = json.loads(args.json)
-    source_id = data.get('source_id', '')
-    quote = data.get('quote', '')
-    if not source_id or not quote:
-        print(json.dumps({'error': 'source_id and quote are required'}), file=sys.stderr)
-        sys.exit(1)
-
-    locator = data.get('locator')
-    evidence_id = compute_evidence_id(source_id, quote, locator)
-    evidence_path = os.path.join(args.dir, 'evidence.jsonl')
-
-    # Check for duplicate
-    existing = read_jsonl(evidence_path)
-    for row in existing:
-        if row.get('evidence_id') == evidence_id:
-            print(json.dumps({
-                'status': 'duplicate',
-                'evidence_id': evidence_id,
-            }))
-            return
-
-    valid_types = {'direct_quote', 'paraphrase', 'data_point', 'figure_reference', 'methodology'}
-    evidence_type = data.get('evidence_type', 'direct_quote')
-    if evidence_type not in valid_types:
-        evidence_type = 'direct_quote'
-
-    row = {
-        'evidence_id': evidence_id,
-        'source_id': source_id,
-        'retrieval_query': data.get('retrieval_query'),
-        'locator': locator,
-        'quote': quote,
-        'evidence_type': evidence_type,
-        'captured_at': datetime.now(timezone.utc).isoformat(),
-    }
-    append_jsonl(evidence_path, row)
-    print(json.dumps({
-        'status': 'added',
-        'evidence_id': evidence_id,
-        'source_id': source_id,
-    }))
-
-
-def cmd_list(args: argparse.Namespace) -> None:
-    """List evidence rows, optionally filtered."""
-    evidence_path = os.path.join(args.dir, 'evidence.jsonl')
-    rows = read_jsonl(evidence_path)
-
-    if args.source_id:
-        rows = [r for r in rows if r.get('source_id') == args.source_id]
-
-    # Deduplicate by evidence_id
-    seen = set()
-    unique = []
-    for r in rows:
-        eid = r.get('evidence_id')
-        if eid not in seen:
-            seen.add(eid)
-            unique.append(r)
-
-    print(json.dumps({
-        'count': len(unique),
-        'evidence': unique,
-    }, indent=2, ensure_ascii=False))
-
-
-def cmd_export(args: argparse.Namespace) -> None:
-    """Export all evidence as JSON array."""
-    evidence_path = os.path.join(args.dir, 'evidence.jsonl')
-    rows = read_jsonl(evidence_path)
-
-    # Deduplicate
-    seen = set()
-    unique = []
-    for r in rows:
-        eid = r.get('evidence_id')
-        if eid not in seen:
-            seen.add(eid)
-            unique.append(r)
-
-    print(json.dumps(unique, indent=2, ensure_ascii=False))
-
-
-# ---------------------------------------------------------------------------
-# CLI entry point
-# ---------------------------------------------------------------------------
-
-def main() -> None:
-    parser = argparse.ArgumentParser(
-        prog='evidence_store',
-        description='Append-only evidence persistence for deep-research v3.0',
-    )
-    sub = parser.add_subparsers(dest='command', required=True)
-
-    # init
-    p_init = sub.add_parser('init', help='Create empty evidence.jsonl')
-    p_init.add_argument('--dir', required=True, help='Run directory')
-
-    # add
-    p_add = sub.add_parser('add', help='Append evidence row')
-    p_add.add_argument('--json', required=True, help='JSON with source_id, quote, locator, evidence_type, retrieval_query')
-    p_add.add_argument('--dir', required=True, help='Run directory containing evidence.jsonl')
-
-    # list
-    p_list = sub.add_parser('list', help='List evidence rows')
-    p_list.add_argument('--dir', required=True, help='Run directory')
-    p_list.add_argument('--source-id', default=None, help='Filter by source_id')
-
-    # export
-    p_export = sub.add_parser('export', help='Export all evidence as JSON array')
-    p_export.add_argument('--dir', required=True, help='Run directory')
-
-    args = parser.parse_args()
-
-    dispatch = {
-        'init': cmd_init,
-        'add': cmd_add,
-        'list': cmd_list,
-        'export': cmd_export,
-    }
-    dispatch[args.command](args)
-
-
-if __name__ == '__main__':
-    main()