sneakoscope 7.1.1 → 7.3.0

package/crates/sks-core/src/search/mod.rs

@@ -0,0 +1,274 @@
+mod files;
+mod text;
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::io::{self, Read};
+use std::time::Instant;
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SearchRequest {
+    #[allow(dead_code)]
+    pub schema_version: u32,
+    pub mode: String,
+    pub root: String,
+    pub query: Option<String>,
+    pub pattern: Option<String>,
+    pub include: Option<Vec<String>>,
+    pub exclude: Option<Vec<String>>,
+    pub case_sensitive: Option<bool>,
+    pub limits: Option<SearchLimits>,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct SearchLimits {
+    pub max_matches: Option<usize>,
+    pub max_files: Option<usize>,
+    pub max_bytes: Option<u64>,
+    pub timeout_ms: Option<u64>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SearchMatch {
+    pub path: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub line: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub column: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub text: Option<String>,
+    pub confidence: String,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SearchResponse {
+    pub schema_version: u32,
+    pub schema: String,
+    pub ok: bool,
+    pub mode: String,
+    pub provider: String,
+    pub engine: String,
+    pub matches: Vec<SearchMatch>,
+    pub confidence: String,
+    pub truncated: bool,
+    pub timeout: bool,
+    pub limits: LimitsOut,
+    pub scanned: ScannedOut,
+    pub skipped: SkippedOut,
+    pub cache_hit: bool,
+    pub warnings: Vec<String>,
+    pub errors: Vec<String>,
+    pub duration_ms: u64,
+    pub process_spawns: u32,
+    pub deterministic_order: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LimitsOut {
+    pub max_matches: usize,
+    pub max_files: usize,
+    pub max_bytes: u64,
+    pub timeout_ms: u64,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ScannedOut {
+    pub files: usize,
+    pub bytes: u64,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SkippedOut {
+    pub files: usize,
+    pub reasons: serde_json::Map<String, Value>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct BatchRequest {
+    #[allow(dead_code)]
+    pub schema_version: u32,
+    pub root: String,
+    pub requests: Vec<SearchRequest>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct BatchResponse {
+    pub schema_version: u32,
+    pub schema: String,
+    pub ok: bool,
+    pub provider: String,
+    pub responses: Vec<SearchResponse>,
+    pub process_spawns: u32,
+    pub duration_ms: u64,
+}
+
+pub fn run(args: &[String]) -> i32 {
+    let mut rest = args.to_vec();
+    let mut json_mode = false;
+    rest.retain(|a| {
+        if a == "--json" {
+            json_mode = true;
+            false
+        } else {
+            true
+        }
+    });
+    if rest.is_empty() || rest[0] == "--help" || rest[0] == "help" {
+        eprintln!("sks-rs search files|text|batch --json  (JSON request on stdin)");
+        return if rest.is_empty() { 2 } else { 0 };
+    }
+    let mode = rest[0].as_str();
+    let started = Instant::now();
+    match mode {
+        "files" | "text" => {
+            let req = read_request();
+            let mut req = match req {
+                Ok(r) => r,
+                Err(e) => {
+                    eprintln!("{}", e);
+                    return 1;
+                }
+            };
+            req.mode = mode.to_string();
+            let resp = dispatch(req);
+            print_json(&resp);
+            if !json_mode {
+                // still JSON for machine responses only
+            }
+            if resp.ok {
+                0
+            } else if resp.errors.iter().any(|e| e.starts_with("invalid_")) {
+                2
+            } else {
+                1
+            }
+        }
+        "batch" => {
+            let batch: BatchRequest = match read_stdin_json() {
+                Ok(v) => v,
+                Err(e) => {
+                    eprintln!("{}", e);
+                    return 1;
+                }
+            };
+            let mut responses = Vec::new();
+            for mut req in batch.requests {
+                if req.root.is_empty() {
+                    req.root = batch.root.clone();
+                }
+                responses.push(dispatch(req));
+            }
+            let out = BatchResponse {
+                schema_version: 1,
+                schema: "sks.search-batch.v1".to_string(),
+                ok: responses.iter().all(|r| r.ok),
+                provider: "sks-rs".to_string(),
+                process_spawns: 1,
+                duration_ms: started.elapsed().as_millis() as u64,
+                responses,
+            };
+            print_json(&out);
+            if out.ok { 0 } else { 1 }
+        }
+        _ => {
+            eprintln!("unknown search mode: {} (files|text|batch)", mode);
+            2
+        }
+    }
+}
+
+fn dispatch(req: SearchRequest) -> SearchResponse {
+    let started = Instant::now();
+    let limits = normalize_limits(req.limits.as_ref());
+    match req.mode.as_str() {
+        "files" => files::search_files(req, limits, started),
+        "text" => text::search_text(req, limits, started),
+        other => error_response(other, limits, started, vec![format!("unsupported_mode:{}", other)]),
+    }
+}
+
+pub(crate) fn normalize_limits(limits: Option<&SearchLimits>) -> LimitsOut {
+    LimitsOut {
+        max_matches: limits.and_then(|l| l.max_matches).unwrap_or(500),
+        max_files: limits.and_then(|l| l.max_files).unwrap_or(50_000),
+        max_bytes: limits.and_then(|l| l.max_bytes).unwrap_or(32 * 1024 * 1024),
+        timeout_ms: limits.and_then(|l| l.timeout_ms).unwrap_or(30_000),
+    }
+}
+
+pub(crate) fn empty_skipped() -> SkippedOut {
+    SkippedOut {
+        files: 0,
+        reasons: serde_json::Map::new(),
+    }
+}
+
+pub(crate) fn bump_skip(skipped: &mut SkippedOut, reason: &str) {
+    skipped.files += 1;
+    let entry = skipped.reasons.entry(reason.to_string()).or_insert(Value::from(0));
+    if let Some(n) = entry.as_u64() {
+        *entry = Value::from(n + 1);
+    }
+}
+
+pub(crate) fn base_ok(mode: &str, engine: &str, limits: LimitsOut, started: Instant) -> SearchResponse {
+    SearchResponse {
+        schema_version: 1,
+        schema: "sks.search-provider.v1".to_string(),
+        ok: true,
+        mode: mode.to_string(),
+        provider: "sks-rs".to_string(),
+        engine: engine.to_string(),
+        matches: vec![],
+        confidence: if mode == "files" { "file_path".into() } else { "text_candidate".into() },
+        truncated: false,
+        timeout: false,
+        limits,
+        scanned: ScannedOut { files: 0, bytes: 0 },
+        skipped: empty_skipped(),
+        cache_hit: false,
+        warnings: vec![],
+        errors: vec![],
+        duration_ms: started.elapsed().as_millis() as u64,
+        process_spawns: 0,
+        deterministic_order: "path_line_column".to_string(),
+    }
+}
+
+fn error_response(mode: &str, limits: LimitsOut, started: Instant, errors: Vec<String>) -> SearchResponse {
+    let mut resp = base_ok(mode, "sks-rs", limits, started);
+    resp.ok = false;
+    resp.errors = errors;
+    resp
+}
+
+fn read_request() -> Result<SearchRequest, String> {
+    read_stdin_json()
+}
+
+fn read_stdin_json<T: for<'de> Deserialize<'de>>() -> Result<T, String> {
+    let mut input = String::new();
+    io::stdin().read_to_string(&mut input).map_err(|e| e.to_string())?;
+    if input.trim().is_empty() {
+        return Err("empty_stdin_json".to_string());
+    }
+    serde_json::from_str(&input).map_err(|e| format!("invalid_json:{}", e))
+}
+
+fn print_json<T: Serialize>(value: &T) {
+    match serde_json::to_string(value) {
+        Ok(s) => println!("{}", s),
+        Err(e) => {
+            eprintln!("{}", e);
+        }
+    }
+}

package/crates/sks-core/src/search/text.rs

@@ -0,0 +1,175 @@
+use super::{bump_skip, base_ok, LimitsOut, SearchMatch, SearchRequest, SearchResponse};
+use globset::{Glob, GlobSet, GlobSetBuilder};
+use grep_matcher::Matcher;
+use grep_regex::RegexMatcherBuilder;
+use grep_searcher::{SearcherBuilder, sinks};
+use ignore::WalkBuilder;
+use std::path::Path;
+use std::time::Instant;
+
+pub fn search_text(req: SearchRequest, limits: LimitsOut, started: Instant) -> SearchResponse {
+    let mut resp = base_ok("text", "grep-searcher", limits.clone(), started);
+    let pattern = req
+        .pattern
+        .as_deref()
+        .or(req.query.as_deref())
+        .unwrap_or("")
+        .to_string();
+    if pattern.is_empty() {
+        resp.ok = false;
+        resp.errors.push("missing_pattern".to_string());
+        resp.duration_ms = started.elapsed().as_millis() as u64;
+        return resp;
+    }
+
+    let case_sensitive = req.case_sensitive.unwrap_or(true);
+    let matcher = match RegexMatcherBuilder::new()
+        .case_insensitive(!case_sensitive)
+        .multi_line(false)
+        .build(&pattern)
+    {
+        Ok(m) => m,
+        Err(e) => {
+            resp.ok = false;
+            resp.errors.push(format!("invalid_regex:{}", e));
+            resp.duration_ms = started.elapsed().as_millis() as u64;
+            return resp;
+        }
+    };
+
+    let root = Path::new(&req.root);
+    let include = build_globset(req.include.as_deref().unwrap_or(&[]));
+    let exclude = build_globset(req.exclude.as_deref().unwrap_or(&[]));
+    let max_matches = resp.limits.max_matches;
+    let max_bytes = resp.limits.max_bytes;
+    let timeout_ms = resp.limits.timeout_ms;
+
+    let mut walker = WalkBuilder::new(root);
+    walker
+        .hidden(true)
+        .git_ignore(true)
+        .git_global(true)
+        .git_exclude(true)
+        .follow_links(false)
+        .max_depth(Some(40))
+        .filter_entry(|entry| {
+            let name = entry.file_name().to_string_lossy();
+            name != ".git" && name != "node_modules" && name != "dist" && name != "target"
+        });
+
+    let mut searcher = SearcherBuilder::new()
+        .binary_detection(grep_searcher::BinaryDetection::quit(b'\x00'))
+        .build();
+    let mut matches: Vec<SearchMatch> = Vec::new();
+    let mut truncated = false;
+
+    for entry in walker.build() {
+        if matches.len() >= max_matches {
+            truncated = true;
+            break;
+        }
+        if started.elapsed().as_millis() as u64 > timeout_ms {
+            resp.timeout = true;
+            truncated = true;
+            break;
+        }
+        let entry = match entry {
+            Ok(e) => e,
+            Err(_) => {
+                bump_skip(&mut resp.skipped, "walk_error");
+                continue;
+            }
+        };
+        if !entry.file_type().map(|t| t.is_file()).unwrap_or(false) {
+            continue;
+        }
+        let abs = entry.path();
+        let rel = match abs.strip_prefix(root) {
+            Ok(p) => p.to_string_lossy().replace('\\', "/"),
+            Err(_) => continue,
+        };
+        if let Some(set) = &exclude {
+            if set.is_match(&rel) {
+                bump_skip(&mut resp.skipped, "exclude");
+                continue;
+            }
+        }
+        if let Some(set) = &include {
+            if !set.is_match(&rel) {
+                bump_skip(&mut resp.skipped, "include");
+                continue;
+            }
+        }
+        let meta = match abs.metadata() {
+            Ok(m) => m,
+            Err(_) => {
+                bump_skip(&mut resp.skipped, "stat");
+                continue;
+            }
+        };
+        if meta.len() > max_bytes {
+            bump_skip(&mut resp.skipped, "too_large");
+            continue;
+        }
+        resp.scanned.files += 1;
+        resp.scanned.bytes += meta.len();
+
+        let mut per_file = 0usize;
+        let rel_for_sink = rel.clone();
+        let sink_truncated = std::cell::Cell::new(false);
+        let result = searcher.search_path(
+            &matcher,
+            abs,
+            sinks::UTF8(|line_num, line| {
+                if matches.len() >= max_matches || per_file >= 50 {
+                    sink_truncated.set(true);
+                    return Ok(false);
+                }
+                let mut col = 1u32;
+                if let Ok(Some(m)) = matcher.find(line.as_bytes()) {
+                    col = (m.start() as u32) + 1;
+                }
+                matches.push(SearchMatch {
+                    path: rel_for_sink.clone(),
+                    line: Some(line_num as u32),
+                    column: Some(col),
+                    text: Some(line.chars().take(240).collect()),
+                    confidence: "text_candidate".to_string(),
+                });
+                per_file += 1;
+                Ok(true)
+            }),
+        );
+        if sink_truncated.get() {
+            truncated = true;
+        }
+        if result.is_err() {
+            bump_skip(&mut resp.skipped, "search_error");
+        }
+    }
+
+    matches.sort_by(|a, b| {
+        a.path
+            .cmp(&b.path)
+            .then(a.line.unwrap_or(0).cmp(&b.line.unwrap_or(0)))
+            .then(a.column.unwrap_or(0).cmp(&b.column.unwrap_or(0)))
+    });
+    resp.matches = matches;
+    resp.truncated = truncated;
+    resp.confidence = "text_candidate".to_string();
+    resp.duration_ms = started.elapsed().as_millis() as u64;
+    resp
+}
+
+fn build_globset(patterns: &[String]) -> Option<GlobSet> {
+    if patterns.is_empty() {
+        return None;
+    }
+    let mut builder = GlobSetBuilder::new();
+    for p in patterns {
+        if let Ok(g) = Glob::new(p) {
+            builder.add(g);
+        }
+    }
+    builder.build().ok()
+}

package/dist/bin/sks-dispatch.js

@@ -13,7 +13,7 @@ async function runSks(args) {
         const { rootJsonFastInline } = await import('./fast-inline.js');
         rootJsonFastInline(fs);
     }
-    else if (args[0] === 'doctor' && args.includes('--json') && !args.includes('--report-file') && !args.includes('--fix') && !args.includes('--full') && !args.includes('--capabilities')) {
+    else if (args[0] === 'doctor' && args.includes('--json') && !args.includes('--report-file') && !args.includes('--fix') && !args.includes('--full') && !args.includes('--capabilities') && !args.includes('--search')) {
         const { doctorJsonFastInline } = await import('./fast-inline.js');
         doctorJsonFastInline();
     }
@@ -36,9 +36,10 @@ async function runSks(args) {
         await narutoHelpJsonFastInline();
     }
     else if (args[0] === 'help' || args[0] === '--help' || args[0] === '-h') {
-        if (args.length > 1) {
+        const topics = args.slice(1).filter((arg) => arg !== '--help' && arg !== '-h');
+        if (topics.length > 0) {
             const { helpCommand } = await import('../core/commands/basic-cli.js');
-            await helpCommand(args.slice(1));
+            await helpCommand(topics);
         }
         else {
             const { helpFast } = await import('../cli/help-fast.js');

package/dist/cli/command-manifest-lite.js

@@ -1,4 +1,5 @@
-export const COMMAND_MANIFEST_LITE = [
+import { NARUTO_ACTIONS } from '../core/safety/command-contract/types.js';
+const COMMAND_MANIFEST_LITE_BASE = [
     { name: 'help', summary: 'Show SKS help', maturity: 'stable', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
     { name: 'version', summary: 'Show SKS version', maturity: 'stable', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
     { name: 'commands', summary: 'List SKS commands', maturity: 'stable', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
@@ -31,9 +32,9 @@ export const COMMAND_MANIFEST_LITE = [
     { name: 'rollback', summary: 'List or apply managed-path rollback actions', maturity: 'beta', skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
     { name: 'postinstall', summary: 'Run postinstall bootstrap', maturity: 'stable', skipMigrationGate: true },
     { name: 'codex', summary: 'Check Codex CLI compatibility and vendored hook schemas', maturity: 'beta', skipMigrationGate: true },
-    { name: 'codex-app', summary: 'Check Codex App readiness', maturity: 'beta' },
+    { name: 'codex-app', summary: 'Check Codex App readiness', maturity: 'beta', skipMigrationGate: true },
     { name: 'codex-native', summary: 'Inspect Codex Native broker and routing readiness', maturity: 'beta' },
-    { name: 'codex-lb', summary: 'Inspect codex-lb status and circuit health', maturity: 'beta' },
+    { name: 'codex-lb', summary: 'Inspect codex-lb status and circuit health', maturity: 'beta', skipMigrationGate: true },
     { name: 'menubar', summary: 'Inspect/install/restart/uninstall SKS menu bar', maturity: 'beta', skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
     { name: 'remote', summary: 'Inspect official Remote readiness and run the proof-aware SSH stdio worker', maturity: 'beta' },
     { name: 'telegram', summary: 'Pair and run the private local Codex Telegram Hub', maturity: 'beta' },
@@ -64,6 +65,7 @@ export const COMMAND_MANIFEST_LITE = [
     { name: 'computer-use', summary: 'Record native Mac/non-web Computer Use visual evidence', maturity: 'beta', mutatesRouteState: true },
     { name: 'context7', summary: 'Context7 checks and docs', maturity: 'beta' },
     { name: 'super-search', summary: 'Run Super-Search provider-independent source intelligence', maturity: 'beta' },
+    { name: 'search', summary: 'Local files/text/structure/symbol/context search engines', maturity: 'beta', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
     { name: 'recallpulse', summary: 'RecallPulse evidence route', maturity: 'labs' },
     { name: 'pipeline', summary: 'Inspect pipeline missions', maturity: 'beta', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
     { name: 'guard', summary: 'Check harness guard', maturity: 'beta' },
@@ -73,7 +75,7 @@ export const COMMAND_MANIFEST_LITE = [
     { name: 'aliases', summary: 'Show command aliases', maturity: 'stable' },
     { name: 'selftest', summary: 'Run local mock selftest', maturity: 'stable' },
     { name: 'goal', summary: 'Print stateless Codex native Goal controls', maturity: 'beta' },
-    { name: 'seo-geo-optimizer', summary: 'Run unified SEO/GEO optimizer audit/research/strategy/plan/apply/verify with optional --include-marketing on the search-visibility kernel', maturity: 'beta' },
+    { name: 'seo-geo-optimizer', summary: 'Run unified SEO/GEO optimizer audit/plan/apply/verify plus research/strategy (--include-marketing) on the search-visibility kernel', maturity: 'beta' },
     { name: 'hook', summary: 'Codex hook entrypoint', maturity: 'beta', skipMigrationGate: true },
     { name: 'profile', summary: 'Inspect/set profile', maturity: 'labs' },
     { name: 'hproof', summary: 'Evaluate H-Proof gate', maturity: 'beta' },
@@ -96,9 +98,178 @@ export const COMMAND_MANIFEST_LITE = [
     { name: 'all-features', summary: 'Run all-features selftest', maturity: 'beta' },
     { name: 'perf', summary: 'Run performance checks', maturity: 'beta' },
     { name: 'bench', summary: 'Run core trust-kernel benchmark budgets', maturity: 'beta' },
-    { name: 'mcp-server', summary: 'Run a stdio MCP server exposing SKS commands as tools for any MCP-capable agent host', maturity: 'beta', skipMigrationGate: true, allowedDuringActiveRoute: true },
+    { name: 'mcp-server', summary: 'Run a stdio MCP server exposing SKS commands as tools for MCP-capable agent hosts', maturity: 'beta', skipMigrationGate: true, allowedDuringActiveRoute: true },
     { name: 'agent-bridge', summary: 'Publish the agent-bridge manifest and print host registration snippets for external agent systems', maturity: 'beta', readonly: true, diagnostic: true }
 ];
+const SAFE_COMMAND_CONTRACT_LITE = {
+    risk: 'R2',
+    latency: 'normal',
+    supportsJson: false,
+    remoteAllowed: false,
+    telegramAllowed: false,
+    inputProfile: 'none',
+    requiredCapabilities: []
+};
+const COMMAND_CONTRACT_OVERRIDES_LITE = {
+    autoresearch: { latency: 'long' },
+    bench: { latency: 'long' },
+    check: { risk: 'R1', latency: 'long' },
+    'commit-and-push': { risk: 'R3' },
+    'computer-use': { latency: 'long' },
+    dfix: { latency: 'long' },
+    'dollar-commands': { risk: 'R2', latency: 'normal' },
+    eval: { latency: 'long' },
+    gates: {
+        risk: 'R1', latency: 'long', supportsJson: true, remoteAllowed: true, telegramAllowed: true,
+        inputProfile: 'gates', requiredCapabilities: ['project.git', 'proof.gates']
+    },
+    harness: { latency: 'long' },
+    'image-ux-review': { latency: 'long' },
+    loop: { latency: 'long' },
+    'mad-sks': { risk: 'R3', latency: 'long' },
+    mcp: { risk: 'R2', latency: 'long', supportsJson: true, inputProfile: 'json-only' },
+    naruto: {
+        risk: 'R2', latency: 'long', supportsJson: true, remoteAllowed: false, telegramAllowed: false,
+        inputProfile: 'naruto'
+    },
+    paths: {
+        supportsJson: true, remoteAllowed: true, inputProfile: 'paths',
+        requiredCapabilities: ['project.fs.read']
+    },
+    perf: { latency: 'long' },
+    pipeline: {
+        risk: 'R2', latency: 'normal', supportsJson: true, remoteAllowed: true, inputProfile: 'pipeline-status',
+        requiredCapabilities: ['proof.pipeline']
+    },
+    postinstall: { latency: 'long' },
+    ppt: { latency: 'long' },
+    proof: {
+        risk: 'R0', latency: 'fast', supportsJson: true, remoteAllowed: true, telegramAllowed: true,
+        inputProfile: 'proof', requiredCapabilities: ['proof.read']
+    },
+    'qa-loop': { latency: 'long' },
+    recallpulse: { latency: 'long' },
+    release: { risk: 'R1', latency: 'long' },
+    remote: { risk: 'R2', latency: 'long', supportsJson: true, remoteAllowed: false, telegramAllowed: false, inputProfile: 'json-only' },
+    research: { latency: 'long' },
+    review: { risk: 'R1' },
+    run: { latency: 'long' },
+    search: { risk: 'R0', latency: 'normal', supportsJson: true, remoteAllowed: true, inputProfile: 'json-only' },
+    stats: {
+        supportsJson: true, remoteAllowed: true, inputProfile: 'stats',
+        requiredCapabilities: ['project.fs.read']
+    },
+    status: {
+        supportsJson: true, remoteAllowed: true, telegramAllowed: true, inputProfile: 'json-only',
+        requiredCapabilities: ['proof.read']
+    },
+    'stop-gate': {
+        supportsJson: true, remoteAllowed: true, telegramAllowed: true, inputProfile: 'stop-gate',
+        requiredCapabilities: ['proof.stop-gate']
+    },
+    task: { risk: 'R1', latency: 'long' },
+    telegram: { risk: 'R2', latency: 'long', supportsJson: true, remoteAllowed: false, telegramAllowed: false, inputProfile: 'json-only' },
+    trust: {
+        risk: 'R0', latency: 'fast', supportsJson: true, remoteAllowed: true, telegramAllowed: true,
+        inputProfile: 'trust', requiredCapabilities: ['proof.trust']
+    },
+    uninstall: { risk: 'R3', latency: 'long' },
+    update: { latency: 'long' },
+    'update-check': {
+        supportsJson: true, remoteAllowed: true, inputProfile: 'json-only',
+        requiredCapabilities: ['network.npm.read']
+    },
+    'validate-artifacts': {
+        risk: 'R1', supportsJson: true, remoteAllowed: true, inputProfile: 'validate-artifacts',
+        requiredCapabilities: ['proof.artifacts']
+    }
+};
+export const COMMAND_MANIFEST_LITE = COMMAND_MANIFEST_LITE_BASE.map((entry) => ({
+    ...SAFE_COMMAND_CONTRACT_LITE,
+    ...('readonly' in entry && entry.readonly === true ? { risk: 'R0', latency: 'fast' } : {}),
+    ...entry,
+    ...(COMMAND_CONTRACT_OVERRIDES_LITE[entry.name] || {})
+}));
+export function commandInputSchema(profile) {
+    if (profile === 'json-only')
+        return objectSchema({ json: { type: 'boolean' } });
+    if (profile === 'naruto') {
+        return objectSchema({
+            action: { type: 'string', enum: [...NARUTO_ACTIONS] },
+            task: boundedString(1, 32_768),
+            prompt: boundedString(1, 32_768),
+            mission: boundedString(1, 160),
+            agents: { type: 'integer', minimum: 1 },
+            max_threads: { type: 'integer', minimum: 1 },
+            readonly: { type: 'boolean' },
+            trusted_project: { type: 'boolean' },
+            json: { type: 'boolean' }
+        });
+    }
+    if (profile === 'paths') {
+        return objectSchema({
+            action: { type: 'string', enum: ['managed', 'git-policy'] },
+            json: { type: 'boolean' }
+        });
+    }
+    if (profile === 'pipeline-status') {
+        return objectSchema({
+            action: { type: 'string', enum: ['status'] },
+            json: { type: 'boolean' }
+        });
+    }
+    if (profile === 'stats')
+        return objectSchema({ full: { type: 'boolean' }, json: { type: 'boolean' } });
+    if (profile === 'stop-gate') {
+        return objectSchema({
+            route: boundedString(1, 80),
+            mission: boundedString(1, 160),
+            gate: boundedString(1, 1024),
+            json: { type: 'boolean' }
+        });
+    }
+    if (profile === 'proof') {
+        return objectSchema({
+            action: { type: 'string', enum: ['show', 'latest', 'validate', 'route'] },
+            mission: boundedString(1, 160),
+            completion: { type: 'boolean' },
+            json: { type: 'boolean' }
+        });
+    }
+    if (profile === 'trust') {
+        return objectSchema({
+            action: { type: 'string', enum: ['report', 'status', 'explain'] },
+            mission: boundedString(1, 160),
+            json: { type: 'boolean' }
+        });
+    }
+    if (profile === 'gates') {
+        return objectSchema({
+            target: boundedString(1, 120),
+            mode: { type: 'string', enum: ['preset', 'gate'] },
+            full: { type: 'boolean' },
+            json: { type: 'boolean' }
+        });
+    }
+    if (profile === 'validate-artifacts') {
+        return objectSchema({
+            mission: boundedString(1, 160),
+            required: {
+                type: 'array',
+                items: boundedString(1, 80),
+                maxItems: 32
+            },
+            json: { type: 'boolean' }
+        });
+    }
+    return objectSchema({});
+}
+function objectSchema(properties) {
+    return { type: 'object', properties, additionalProperties: false };
+}
+function boundedString(minLength, maxLength) {
+    return { type: 'string', minLength, maxLength };
+}
 export const LEGACY_COMMAND_ALIASES_LITE = {};
 export const COMMAND_ALIASES_LITE = {
     ...LEGACY_COMMAND_ALIASES_LITE,