@guanlin4924/devflow-pi 0.1.75 → 0.1.77

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guanlin4924/devflow-pi",
-  "version": "0.1.75",
+  "version": "0.1.77",
   "type": "module",
   "description": "Devflow 专项研发 Pi，基于固定版本 OMP Runtime 组装研发状态机、代码智能、设计、实现与质量门禁。",
   "license": "UNLICENSED",

package/plugins/devflow-core/extensions/devflow-core.ts

@@ -1318,7 +1318,7 @@ export default function devflowCore(pi: ExtensionAPI) {
               value = await store.registerWorkspace({ rebindWorkspaceId: params.workspaceId });
             } else if (params.action === "cancel") {
               if (!params.runId) throw new Error("runId is required for cancel");
-              value = { runId: params.runId, cancelled: store.cancelRun(params.runId) };
+              value = { runId: params.runId, cancelled: store.cancelRunByOperator(params.runId) };
             } else if (params.action === "recover") {
               if (!params.runId) throw new Error("runId is required for recover");
               value = { runId: params.runId, ...store.recoverRun(params.runId) };

package/plugins/devflow-core/skills/workflow-project-context/scripts/validate_initialization_database.py

@@ -61,6 +61,8 @@ def validate(database: Path, project_id: str, workspace_id: str | None = None, r
         for run in runs[:1] if not run_id else runs:
             if run["status"] not in TERMINAL_STATUSES | {"preparing", "collecting", "validating"}:
                 errors.append(f"invalid run status: {run['status']}")
+            if run["status"] != "finished":
+                errors.append(f"initialization run is not finished: {run['status']}")
             results = connection.execute(
                 "SELECT repository,kind,status FROM collection_results WHERE run_id=?", (run["id"],)
             ).fetchall()

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/base.py

@@ -12,6 +12,9 @@ class ParseResult:
     # in a separate linker pass.
     entities: List[Dict] = field(default_factory=list)
     flows: List[Dict] = field(default_factory=list)
+    # Parser that actually produced this result.  This can differ from the
+    # selected adapter when a native parser fails and a fallback is used.
+    actual_parser: str = ""
 
 
 class Adapter:
@@ -29,6 +32,23 @@ class Adapter:
     def version(self) -> str:
         return "0"
 
+    def parser_for_file(self, codebase, file_record) -> str:
+        """Return the parser that will actually produce this file's facts.
+
+        Native adapters override this when their runtime dependency is not
+        available and a declared fallback will be used instead.  Keeping this
+        separate from ``parser_id`` prevents fallback output from being
+        labelled as native AST output.
+        """
+        return self.parser_id
+
+    def capability(self) -> Dict:
+        return {
+            "parser": self.parser_id,
+            "native": False,
+            "available": True,
+        }
+
     @property
     def parser_id(self) -> str:
         return f"{self.name}@{self.version()}"

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/generic_text.py

@@ -155,7 +155,7 @@ class GenericTextAdapter(Adapter):
                 }
             )
 
-        return ParseResult(symbols=symbols, relations=relations, diagnostics=diagnostics)
+        return ParseResult(symbols=symbols, relations=relations, diagnostics=diagnostics, actual_parser=self.parser_id)
 
     def _extract_symbols(self, codebase: str, language: str, path: str, text: str, content_hash: str) -> List[Dict]:
         symbols: List[Dict] = []

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/go_ast.py

@@ -0,0 +1,20 @@
+import shutil
+from typing import List, Tuple
+
+from adapters.native_process import HELPER_DIR, NativeProcessAdapter
+
+
+class GoAstAdapter(NativeProcessAdapter):
+    name = "go-parser-ast"
+    languages = ("go",)
+    native_description = "Go standard library go parser AST; declarations, imports, and calls"
+
+    def version(self) -> str:
+        return "1"
+
+    def check_available(self, codebase=None) -> Tuple[bool, str]:
+        go = shutil.which("go")
+        return (True, "go/parser available") if go else (False, "go executable not found")
+
+    def command(self, codebase=None) -> List[str]:
+        return [shutil.which("go") or "go", "run", str(HELPER_DIR / "go_ast_helper.go")]

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/helpers/DevflowJavaAstHelper.java

@@ -0,0 +1,96 @@
+import java.io.*;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import javax.tools.*;
+import javax.lang.model.element.Modifier;
+import com.sun.source.tree.*;
+import com.sun.source.util.*;
+
+public final class DevflowJavaAstHelper {
+  private static String json(String value) {
+    if (value == null) return "\"\"";
+    StringBuilder out = new StringBuilder("\"");
+    for (char c : value.toCharArray()) {
+      switch (c) {
+        case '\\': out.append("\\\\"); break;
+        case '"': out.append("\\\""); break;
+        case '\n': out.append("\\n"); break;
+        case '\r': out.append("\\r"); break;
+        case '\t': out.append("\\t"); break;
+        default:
+          if (c < 32) out.append(String.format("\\u%04x", (int)c)); else out.append(c);
+      }
+    }
+    return out.append('"').toString();
+  }
+
+  private static final class Source extends SimpleJavaFileObject {
+    final String text;
+    Source(String path, String text) { super(URI.create("string:///" + path.replace(' ', '_')), Kind.SOURCE); this.text = text; }
+    public CharSequence getCharContent(boolean ignoreEncodingErrors) { return text; }
+  }
+
+  private static final class Decl {
+    String key, parent, kind, name, signature, nativeKind, visibility; int start, end;
+    String toJson() { return "{\"key\":"+json(key)+",\"parent\":"+json(parent)+",\"kind\":"+json(kind)+",\"name\":"+json(name)+",\"line_start\":"+start+",\"line_end\":"+end+",\"signature\":"+json(signature)+",\"native_kind\":"+json(nativeKind)+",\"visibility\":"+json(visibility)+"}"; }
+  }
+  private static final class Rel {
+    String owner, type, target, confidence, resolution; int line;
+    String toJson() { return "{\"owner\":"+json(owner)+",\"type\":"+json(type)+",\"target\":"+json(target)+",\"line\":"+line+",\"confidence\":"+json(confidence)+",\"metadata\":{\"resolution\":"+json(resolution)+"}}"; }
+  }
+
+  private static String parse(String path, String sourceText) throws Exception {
+    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+    if (compiler == null) throw new IllegalStateException("JDK compiler API unavailable");
+    DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
+    JavacTask task = (JavacTask) compiler.getTask(null, null, diagnostics, List.of("-proc:none"), null, List.of(new Source(path, sourceText)));
+    CompilationUnitTree unit = task.parse().iterator().next();
+    Trees trees = Trees.instance(task); SourcePositions positions = trees.getSourcePositions(); LineMap lines = unit.getLineMap();
+    List<Decl> declarations = new ArrayList<>(); List<Rel> relations = new ArrayList<>();
+    new TreePathScanner<Void, String>() {
+      int next = 1;
+      int line(Tree tree) { long p = positions.getStartPosition(unit, tree); return p < 0 ? 1 : (int)lines.getLineNumber(p); }
+      int end(Tree tree) { long p = positions.getEndPosition(unit, tree); return p < 0 ? line(tree) : (int)lines.getLineNumber(Math.max(0, p - 1)); }
+      String visibility(Set<Modifier> modifiers) { if (modifiers.contains(Modifier.PUBLIC)) return "public"; if (modifiers.contains(Modifier.PROTECTED)) return "protected"; if (modifiers.contains(Modifier.PRIVATE)) return "private"; return ""; }
+      String addDecl(Tree tree, String parent, String kind, String name, String signature, Set<Modifier> modifiers) {
+        Decl d = new Decl(); d.key = String.valueOf(next++); d.parent = parent == null ? "" : parent; d.kind = kind; d.name = name; d.signature = signature; d.nativeKind = tree.getKind().name(); d.visibility = visibility(modifiers); d.start = line(tree); d.end = Math.max(d.start, end(tree)); declarations.add(d); return d.key;
+      }
+      void addRel(String owner, String type, String target, Tree tree, String confidence, String resolution) { Rel r = new Rel(); r.owner=owner==null?"":owner; r.type=type; r.target=target; r.line=line(tree); r.confidence=confidence; r.resolution=resolution; relations.add(r); }
+      @Override public Void visitClass(ClassTree node, String owner) {
+        String kind = node.getKind() == Tree.Kind.INTERFACE || node.getKind() == Tree.Kind.ANNOTATION_TYPE ? "interface" : "class";
+        String key = addDecl(node, owner, kind, node.getSimpleName().toString(), node.getSimpleName()+"()", node.getModifiers().getFlags());
+        if (node.getExtendsClause() != null) addRel(key, "extends", "type:"+node.getExtendsClause(), node.getExtendsClause(), "inferred", "syntax_name");
+        for (Tree inherited : node.getImplementsClause()) addRel(key, "implements", "type:"+inherited, inherited, "inferred", "syntax_name");
+        return super.visitClass(node, key);
+      }
+      @Override public Void visitMethod(MethodTree node, String owner) {
+        String name = node.getName().toString(); String kind = name.toLowerCase().startsWith("test") ? "test" : "method";
+        String key = addDecl(node, owner, kind, name, name+"("+String.join(", ", node.getParameters().stream().map(v -> v.getName().toString()).toList())+")", node.getModifiers().getFlags());
+        return super.visitMethod(node, key);
+      }
+      @Override public Void visitImport(ImportTree node, String owner) { addRel(owner, "imports", "import:"+node.getQualifiedIdentifier(), node, "exact", "import_tree"); return super.visitImport(node, owner); }
+      @Override public Void visitMethodInvocation(MethodInvocationTree node, String owner) {
+        String target=node.getMethodSelect().toString(); boolean receiver=target.contains("."); addRel(owner, "calls", "call:"+target, node, receiver?"heuristic":"inferred", receiver?"receiver_unresolved":"lexical_name"); return super.visitMethodInvocation(node, owner);
+      }
+      @Override public Void visitNewClass(NewClassTree node, String owner) { addRel(owner, "calls", "call:"+node.getIdentifier(), node, "inferred", "constructor_syntax"); return super.visitNewClass(node, owner); }
+    }.scan(unit, "");
+    StringBuilder out = new StringBuilder("{\"ok\":true,\"declarations\":[");
+    for (int i=0;i<declarations.size();i++) { if(i>0) out.append(','); out.append(declarations.get(i).toJson()); }
+    out.append("],\"relations\":["); for(int i=0;i<relations.size();i++){if(i>0)out.append(',');out.append(relations.get(i).toJson());}
+    out.append("],\"diagnostics\":["); boolean first=true; for(Diagnostic<? extends JavaFileObject> d: diagnostics.getDiagnostics()){if(!first)out.append(',');first=false;out.append("{\"line\":").append(Math.max(1,d.getLineNumber())).append(",\"severity\":\"warning\",\"kind\":\"parse_failed\",\"message\":").append(json(d.getMessage(Locale.ROOT))).append('}');}
+    return out.append("]}").toString();
+  }
+
+  public static void main(String[] args) throws Exception {
+    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8)); String line;
+    while ((line = reader.readLine()) != null) {
+      try {
+        String[] parts=line.split("\\t",2); if(parts.length!=2)throw new IllegalArgumentException("invalid request");
+        String path=new String(Base64.getDecoder().decode(parts[0]),StandardCharsets.UTF_8); String source=new String(Base64.getDecoder().decode(parts[1]),StandardCharsets.UTF_8);
+        System.out.println(parse(path,source));
+      } catch(Exception error) { System.out.println("{\"ok\":false,\"error\":"+json(error.toString())+"}"); }
+      System.out.flush();
+    }
+  }
+}

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/helpers/go_ast_helper.go

@@ -0,0 +1,96 @@
+package main
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strings"
+)
+
+type Request struct { Path string `json:"path"`; Source string `json:"source"` }
+type Declaration struct { Key string `json:"key"`; Parent string `json:"parent"`; Kind string `json:"kind"`; Name string `json:"name"`; LineStart int `json:"line_start"`; LineEnd int `json:"line_end"`; Signature string `json:"signature"`; NativeKind string `json:"native_kind"` }
+type Relation struct { Owner string `json:"owner"`; Type string `json:"type"`; Target string `json:"target"`; Line int `json:"line"`; Confidence string `json:"confidence"`; Metadata map[string]any `json:"metadata"` }
+type Diagnostic struct { Line int `json:"line"`; Severity string `json:"severity"`; Kind string `json:"kind"`; Message string `json:"message"` }
+type Response struct { Ok bool `json:"ok"`; Error string `json:"error,omitempty"`; Declarations []Declaration `json:"declarations,omitempty"`; Relations []Relation `json:"relations,omitempty"`; Diagnostics []Diagnostic `json:"diagnostics,omitempty"` }
+
+func expressionName(expr ast.Expr) string {
+	switch value := expr.(type) {
+	case *ast.Ident: return value.Name
+	case *ast.SelectorExpr:
+		parent := expressionName(value.X)
+		if parent != "" { return parent + "." + value.Sel.Name }
+		return value.Sel.Name
+	case *ast.IndexExpr: return expressionName(value.X)
+	case *ast.IndexListExpr: return expressionName(value.X)
+	}
+	return ""
+}
+
+func parseRequest(request Request) Response {
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, request.Path, request.Source, parser.AllErrors|parser.ParseComments)
+	response := Response{Ok: true, Declarations: []Declaration{}, Relations: []Relation{}, Diagnostics: []Diagnostic{}}
+	if err != nil {
+		line := 1
+		if list, ok := err.(interface{ Error() string }); ok { _ = list }
+		response.Diagnostics = append(response.Diagnostics, Diagnostic{Line: line, Severity: "warning", Kind: "parse_failed", Message: err.Error()})
+	}
+	if file == nil { response.Ok = false; response.Error = "go/parser produced no syntax tree"; return response }
+	keys := map[ast.Node]string{}
+	next := 1
+	for _, declaration := range file.Decls {
+		switch node := declaration.(type) {
+		case *ast.FuncDecl:
+			key := fmt.Sprintf("%d", next); next++
+			keys[node] = key
+			kind := "function"
+			if node.Recv != nil { kind = "method" }
+			if strings.HasPrefix(strings.ToLower(node.Name.Name), "test") { kind = "test" }
+			response.Declarations = append(response.Declarations, Declaration{Key:key, Kind:kind, Name:node.Name.Name, LineStart:fset.Position(node.Pos()).Line, LineEnd:fset.Position(node.End()).Line, Signature:node.Name.Name+"()", NativeKind:"FuncDecl"})
+		case *ast.GenDecl:
+			for _, spec := range node.Specs {
+				if typeSpec, ok := spec.(*ast.TypeSpec); ok {
+					key := fmt.Sprintf("%d", next); next++
+					keys[typeSpec] = key
+					kind := "class"
+					native := "TypeSpec"
+					switch typeSpec.Type.(type) { case *ast.StructType: kind="struct"; native="StructType"; case *ast.InterfaceType: kind="interface"; native="InterfaceType" }
+					response.Declarations = append(response.Declarations, Declaration{Key:key, Kind:kind, Name:typeSpec.Name.Name, LineStart:fset.Position(typeSpec.Pos()).Line, LineEnd:fset.Position(typeSpec.End()).Line, Signature:typeSpec.Name.Name, NativeKind:native})
+				}
+			}
+		}
+	}
+	for _, imp := range file.Imports {
+		target := strings.Trim(imp.Path.Value, "\"")
+		response.Relations = append(response.Relations, Relation{Type:"imports", Target:"import:"+target, Line:fset.Position(imp.Pos()).Line, Confidence:"exact", Metadata:map[string]any{"resolution":"import_spec"}})
+	}
+	for _, declaration := range file.Decls {
+		owner := keys[declaration]
+		ast.Inspect(declaration, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if !ok { return true }
+			name := expressionName(call.Fun)
+			if name == "" { return true }
+			confidence := "inferred"; resolution := "lexical_name"
+			if strings.Contains(name, ".") { confidence = "heuristic"; resolution = "receiver_unresolved" }
+			response.Relations = append(response.Relations, Relation{Owner:owner, Type:"calls", Target:"call:"+name, Line:fset.Position(call.Pos()).Line, Confidence:confidence, Metadata:map[string]any{"resolution":resolution}})
+			return true
+		})
+	}
+	return response
+}
+
+func main() {
+	scanner := bufio.NewScanner(os.Stdin)
+	buffer := make([]byte, 64*1024); scanner.Buffer(buffer, 64*1024*1024)
+	encoder := json.NewEncoder(os.Stdout)
+	for scanner.Scan() {
+		var request Request
+		if err := json.Unmarshal(scanner.Bytes(), &request); err != nil { encoder.Encode(Response{Ok:false, Error:err.Error()}); continue }
+		encoder.Encode(parseRequest(request))
+	}
+}

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/helpers/php_ast_helper.php

@@ -0,0 +1,91 @@
+<?php
+declare(strict_types=1);
+
+$autoload = $argv[1] ?? '';
+if (!$autoload || !is_file($autoload)) {
+    fwrite(STDOUT, json_encode(['ok' => false, 'error' => 'nikic/PHP-Parser autoload file not found']) . "\n");
+    exit(2);
+}
+require_once $autoload;
+
+function node_name($node): string {
+    if ($node instanceof PhpParser\Node\Name || $node instanceof PhpParser\Node\Identifier || $node instanceof PhpParser\Node\VarLikeIdentifier) {
+        return $node->toString();
+    }
+    if ($node instanceof PhpParser\Node\Expr\Variable && is_string($node->name)) return '$' . $node->name;
+    if (is_string($node)) return $node;
+    return '';
+}
+
+function relation_target($node): string {
+    if ($node instanceof PhpParser\Node\Name || $node instanceof PhpParser\Node\Identifier) return $node->toString();
+    if ($node instanceof PhpParser\Node\Expr\Variable) return node_name($node);
+    if ($node instanceof PhpParser\Node\Expr\PropertyFetch || $node instanceof PhpParser\Node\Expr\StaticPropertyFetch) {
+        return trim(relation_target($node->var ?? $node->class) . '->' . node_name($node->name), '->');
+    }
+    return '';
+}
+
+function parser_instance() {
+    $factory = new PhpParser\ParserFactory();
+    if (method_exists($factory, 'createForNewestSupportedVersion')) return $factory->createForNewestSupportedVersion();
+    return $factory->create(PhpParser\ParserFactory::PREFER_PHP7);
+}
+
+function parse_source(string $source): array {
+    $declarations = []; $relations = []; $diagnostics = []; $next = 1;
+    try { $nodes = parser_instance()->parse($source) ?? []; }
+    catch (PhpParser\Error $error) {
+        return ['ok' => true, 'declarations' => [], 'relations' => [], 'diagnostics' => [[
+            'line' => max(1, $error->getStartLine()), 'severity' => 'warning', 'kind' => 'parse_failed', 'message' => $error->getMessage()
+        ]]];
+    }
+    $walk = function ($node, string $owner = '') use (&$walk, &$declarations, &$relations, &$next): void {
+        if (!$node instanceof PhpParser\Node) return;
+        $current = $owner; $kind = null; $name = '';
+        if ($node instanceof PhpParser\Node\Stmt\Class_) { $kind = 'class'; $name = node_name($node->name) ?: 'anonymous'; }
+        elseif ($node instanceof PhpParser\Node\Stmt\Interface_) { $kind = 'interface'; $name = node_name($node->name); }
+        elseif ($node instanceof PhpParser\Node\Stmt\Trait_) { $kind = 'trait'; $name = node_name($node->name); }
+        elseif ($node instanceof PhpParser\Node\Stmt\Function_) { $kind = str_starts_with(strtolower(node_name($node->name)), 'test') ? 'test' : 'function'; $name = node_name($node->name); }
+        elseif ($node instanceof PhpParser\Node\Stmt\ClassMethod) { $kind = str_starts_with(strtolower(node_name($node->name)), 'test') ? 'test' : 'method'; $name = node_name($node->name); }
+        elseif ($node instanceof PhpParser\Node\Expr\Closure || $node instanceof PhpParser\Node\Expr\ArrowFunction) { $kind = 'function'; $name = 'anonymous'; }
+        if ($kind !== null) {
+            $current = (string)$next++;
+            $params = property_exists($node, 'params') ? array_map(fn($p) => node_name($p->var), $node->params) : [];
+            $visibility = method_exists($node, 'isPrivate') && $node->isPrivate() ? 'private' : (method_exists($node, 'isProtected') && $node->isProtected() ? 'protected' : (method_exists($node, 'isPublic') && $node->isPublic() ? 'public' : ''));
+            $declarations[] = ['key'=>$current,'parent'=>$owner,'kind'=>$kind,'name'=>$name,'line_start'=>max(1,$node->getStartLine()),'line_end'=>max(1,$node->getEndLine()),'signature'=>$name.'('.implode(', ',$params).')','visibility'=>$visibility,'native_kind'=>$node->getType()];
+            if ($node instanceof PhpParser\Node\Stmt\Class_) {
+                if ($node->extends) $relations[] = ['owner'=>$current,'type'=>'extends','target'=>'type:'.node_name($node->extends),'line'=>$node->extends->getStartLine(),'confidence'=>'inferred','metadata'=>['resolution'=>'syntax_name']];
+                foreach ($node->implements as $type) $relations[] = ['owner'=>$current,'type'=>'implements','target'=>'type:'.node_name($type),'line'=>$type->getStartLine(),'confidence'=>'inferred','metadata'=>['resolution'=>'syntax_name']];
+            }
+        }
+        if ($node instanceof PhpParser\Node\Stmt\Use_ || $node instanceof PhpParser\Node\Stmt\GroupUse) {
+            foreach ($node->uses as $use) $relations[] = ['owner'=>$owner,'type'=>'imports','target'=>'import:'.node_name($use->name),'line'=>$use->getStartLine(),'confidence'=>'exact','metadata'=>['resolution'=>'use_tree']];
+        } elseif ($node instanceof PhpParser\Node\Expr\FuncCall) {
+            $target = node_name($node->name); if ($target) $relations[] = ['owner'=>$owner,'type'=>'calls','target'=>'call:'.$target,'line'=>$node->getStartLine(),'confidence'=>'inferred','metadata'=>['resolution'=>'syntax_name']];
+        } elseif ($node instanceof PhpParser\Node\Expr\MethodCall || $node instanceof PhpParser\Node\Expr\NullsafeMethodCall) {
+            $target = node_name($node->name); if ($target) $relations[] = ['owner'=>$owner,'type'=>'calls','target'=>'call:'.$target,'line'=>$node->getStartLine(),'confidence'=>'heuristic','metadata'=>['resolution'=>'receiver_unresolved']];
+        } elseif ($node instanceof PhpParser\Node\Expr\StaticCall) {
+            $target = node_name($node->class).'::'.node_name($node->name); if ($target !== '::') $relations[] = ['owner'=>$owner,'type'=>'calls','target'=>'call:'.$target,'line'=>$node->getStartLine(),'confidence'=>'heuristic','metadata'=>['resolution'=>'static_receiver_unresolved']];
+        } elseif ($node instanceof PhpParser\Node\Expr\New_) {
+            $target = node_name($node->class); if ($target) $relations[] = ['owner'=>$owner,'type'=>'calls','target'=>'call:'.$target,'line'=>$node->getStartLine(),'confidence'=>'inferred','metadata'=>['resolution'=>'constructor_syntax']];
+        }
+        foreach ($node->getSubNodeNames() as $field) {
+            $value = $node->$field;
+            if ($value instanceof PhpParser\Node) $walk($value, $current);
+            elseif (is_array($value)) foreach ($value as $child) if ($child instanceof PhpParser\Node) $walk($child, $current);
+        }
+    };
+    foreach ($nodes as $node) $walk($node, '');
+    return ['ok'=>true,'declarations'=>$declarations,'relations'=>$relations,'diagnostics'=>$diagnostics];
+}
+
+while (($line = fgets(STDIN)) !== false) {
+    try {
+        $request = json_decode($line, true, 512, JSON_THROW_ON_ERROR);
+        echo json_encode(parse_source((string)($request['source'] ?? '')), JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES) . "\n";
+    } catch (Throwable $error) {
+        echo json_encode(['ok'=>false,'error'=>$error->getMessage()], JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES) . "\n";
+    }
+    flush();
+}

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/helpers/typescript_ast_helper.cjs

@@ -0,0 +1,123 @@
+const readline = require("readline");
+
+let ts;
+try {
+  ts = require("typescript");
+} catch (error) {
+  process.stdout.write(JSON.stringify({ ok: false, error: `typescript compiler API unavailable: ${error.message}` }) + "\n");
+  process.exit(2);
+}
+
+function scriptKind(path) {
+  if (path.endsWith(".tsx")) return ts.ScriptKind.TSX;
+  if (path.endsWith(".jsx")) return ts.ScriptKind.JSX;
+  if (path.endsWith(".js") || path.endsWith(".mjs") || path.endsWith(".cjs")) return ts.ScriptKind.JS;
+  return ts.ScriptKind.TS;
+}
+
+function parse(input) {
+  const source = ts.createSourceFile(input.path, input.source, ts.ScriptTarget.Latest, true, scriptKind(input.path));
+  const declarations = [];
+  const relations = [];
+  let nextKey = 1;
+
+  function line(node) {
+    return source.getLineAndCharacterOfPosition(node.getStart(source, false)).line + 1;
+  }
+  function endLine(node) {
+    return source.getLineAndCharacterOfPosition(node.end).line + 1;
+  }
+  function nodeName(node) {
+    if (node.name && ts.isIdentifier(node.name)) return node.name.text;
+    if (node.name && ts.isStringLiteralLike(node.name)) return node.name.text;
+    return "anonymous";
+  }
+  function signature(node, name) {
+    if (node.parameters) {
+      const parameters = node.parameters.map((p) => p.name.getText(source));
+      return `${name}(${parameters.join(", ")})`;
+    }
+    return `${name}()`;
+  }
+  function visibility(node) {
+    const modifiers = node.modifiers || [];
+    if (modifiers.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword)) return "private";
+    if (modifiers.some((m) => m.kind === ts.SyntaxKind.ProtectedKeyword)) return "protected";
+    if (modifiers.some((m) => m.kind === ts.SyntaxKind.PublicKeyword)) return "public";
+    return "";
+  }
+  function declarationKind(node) {
+    if (ts.isClassDeclaration(node) || ts.isEnumDeclaration(node)) return "class";
+    if (ts.isInterfaceDeclaration(node)) return "interface";
+    if (ts.isModuleDeclaration(node)) return "module";
+    if (ts.isMethodDeclaration(node) || ts.isMethodSignature(node) || ts.isConstructorDeclaration(node)) return "method";
+    if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node)) return "function";
+    return null;
+  }
+  function callTarget(expression) {
+    if (ts.isIdentifier(expression)) return { target: expression.text, confidence: "inferred", resolution: "lexical_name" };
+    if (ts.isPropertyAccessExpression(expression)) return { target: expression.getText(source), confidence: "heuristic", resolution: "receiver_unresolved" };
+    if (ts.isElementAccessExpression(expression)) return { target: expression.getText(source), confidence: "heuristic", resolution: "dynamic_element" };
+    return null;
+  }
+  function addRelation(owner, type, target, at, confidence, metadata = {}) {
+    relations.push({ owner: owner || "", type, target, line: at, confidence, metadata });
+  }
+  function visit(node, owner = "") {
+    let current = owner;
+    let kind = declarationKind(node);
+    let name = nodeName(node);
+    if (ts.isVariableDeclaration(node) && node.initializer && (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
+      kind = "function";
+      name = node.name.getText(source);
+    }
+    if (kind) {
+      const key = String(nextKey++);
+      declarations.push({
+        key,
+        parent: owner,
+        kind: name.toLowerCase().startsWith("test") && kind === "function" ? "test" : kind,
+        name,
+        line_start: line(node),
+        line_end: endLine(node),
+        signature: signature(node, name),
+        visibility: visibility(node),
+        native_kind: ts.SyntaxKind[node.kind],
+      });
+      current = key;
+      const heritage = node.heritageClauses || [];
+      for (const clause of heritage) {
+        const type = clause.token === ts.SyntaxKind.ImplementsKeyword ? "implements" : "extends";
+        for (const inherited of clause.types) {
+          addRelation(current, type, `type:${inherited.expression.getText(source)}`, line(inherited), "inferred", { resolution: "syntax_name" });
+        }
+      }
+    }
+    if (ts.isImportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteralLike(node.moduleSpecifier)) {
+      addRelation(owner, "imports", `import:${node.moduleSpecifier.text}`, line(node), "exact", { resolution: "module_specifier" });
+    } else if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteralLike(node.moduleSpecifier)) {
+      addRelation(owner, "imports", `import:${node.moduleSpecifier.text}`, line(node), "exact", { resolution: "export_module_specifier" });
+    } else if (ts.isCallExpression(node)) {
+      const target = callTarget(node.expression);
+      if (target) addRelation(owner, "calls", `call:${target.target}`, line(node), target.confidence, { resolution: target.resolution });
+    }
+    ts.forEachChild(node, (child) => visit(child, current));
+  }
+  visit(source, "");
+  const diagnostics = source.parseDiagnostics.map((diagnostic) => ({
+    line: diagnostic.start == null ? 1 : source.getLineAndCharacterOfPosition(diagnostic.start).line + 1,
+    severity: "warning",
+    kind: "parse_failed",
+    message: ts.flattenDiagnosticMessageText(diagnostic.messageText, " "),
+  }));
+  return { ok: true, declarations, relations, diagnostics };
+}
+
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+rl.on("line", (line) => {
+  try {
+    process.stdout.write(JSON.stringify(parse(JSON.parse(line))) + "\n");
+  } catch (error) {
+    process.stdout.write(JSON.stringify({ ok: false, error: error.stack || error.message || String(error) }) + "\n");
+  }
+});

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/java_ast.py

@@ -0,0 +1,37 @@
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Tuple
+
+from adapters.native_process import HELPER_DIR, NativeProcessAdapter
+
+
+class JavaAstAdapter(NativeProcessAdapter):
+    name = "javac-tree-ast"
+    languages = ("java",)
+    native_description = "JDK javac com.sun.source Tree API; declarations, imports, and calls"
+    transport = "base64-tsv"
+
+    def __init__(self, fallback):
+        super().__init__(fallback)
+        self.classes = Path(tempfile.gettempdir()) / "devflow-java-ast-helper-v1"
+
+    def version(self) -> str:
+        return "1"
+
+    def check_available(self, codebase=None) -> Tuple[bool, str]:
+        javac, java = shutil.which("javac"), shutil.which("java")
+        if not javac or not java:
+            return False, "JDK javac/java executables not found"
+        source = HELPER_DIR / "DevflowJavaAstHelper.java"
+        target = self.classes / "DevflowJavaAstHelper.class"
+        if not target.exists() or target.stat().st_mtime < source.stat().st_mtime:
+            self.classes.mkdir(parents=True, exist_ok=True)
+            result = subprocess.run([javac, "-d", str(self.classes), str(source)], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=False)
+            if result.returncode != 0:
+                return False, f"javac Tree API helper compilation failed: {result.stderr.strip()[:500]}"
+        return True, "JDK javac Tree API available"
+
+    def command(self, codebase=None) -> List[str]:
+        return [shutil.which("java") or "java", "-cp", str(self.classes), "DevflowJavaAstHelper"]

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/native_process.py

@@ -0,0 +1,328 @@
+import base64
+import json
+import os
+import select
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Tuple
+
+from adapters.base import Adapter, ParseResult
+from adapters.generic_text import _relation, _symbol
+
+
+HELPER_DIR = Path(__file__).resolve().parent / "helpers"
+
+
+class NativeProcessAdapter(Adapter):
+    """Base class for language-native parsers exposed through JSONL helpers.
+
+    Helpers stay alive for the lifetime of one index scan, which avoids the
+    process-startup cost for every source file.  They return syntax facts only;
+    this class converts those facts into the stable shared index schema.
+    """
+
+    languages: Tuple[str, ...] = ()
+    native_description = "language-native syntax parser"
+    transport = "json"
+
+    def __init__(self, fallback: Adapter):
+        self.fallback = fallback
+        self._processes: Dict[str, subprocess.Popen] = {}
+        self._availability: Dict[str, Tuple[bool, str]] = {}
+
+    def detect(self, codebase, files, manifests) -> int:
+        return 120 if any(self._language_for_path(path) in self.languages for path in files) else 0
+
+    def supports(self, language: str) -> bool:
+        return language in self.languages
+
+    def check_available(self, codebase=None) -> Tuple[bool, str]:
+        raise NotImplementedError
+
+    def command(self, codebase=None) -> List[str]:
+        raise NotImplementedError
+
+    def _availability_for(self, codebase=None) -> Tuple[bool, str]:
+        key = self._availability_key(codebase)
+        if key not in self._availability:
+            self._availability[key] = self.check_available(codebase)
+        return self._availability[key]
+
+    @staticmethod
+    def _availability_key(codebase=None) -> str:
+        if codebase is None:
+            return "<global>"
+        root = getattr(codebase, "root", None)
+        if root is not None:
+            try:
+                return str(Path(root).resolve())
+            except OSError:
+                return str(root)
+        return f"<codebase:{getattr(codebase, 'name', id(codebase))}>"
+
+    def parser_for_file(self, codebase, file_record) -> str:
+        available, _ = self._availability_for(codebase)
+        return self.parser_id if available else self.fallback.parser_for_file(codebase, file_record)
+
+    def capability(self) -> Dict:
+        codebase_results = [value for key, value in self._availability.items() if key != "<global>"]
+        if codebase_results:
+            available = any(value[0] for value in codebase_results)
+            reasons = sorted({value[1] for value in codebase_results})
+            reason = "; ".join(reasons)
+        else:
+            available, reason = self._availability_for(None)
+        return {
+            "parser": self.parser_id,
+            "languages": list(self.languages),
+            "native": True,
+            "available": available,
+            "reason": reason,
+            "fallback": self.fallback.parser_id,
+            "scope": self.native_description,
+        }
+
+    def parse_file(self, codebase, file_record, text) -> ParseResult:
+        if not self.supports(file_record["language"]):
+            return self.fallback.parse_file(codebase, file_record, text)
+        available, reason = self._availability_for(codebase)
+        if not available:
+            return self._fallback_result(codebase, file_record, text, reason)
+        try:
+            payload = self._request(codebase, file_record, text)
+        except Exception as error:
+            self._stop_process(codebase)
+            return self._fallback_result(codebase, file_record, text, f"native parser failed: {error}", kind="parse_failed")
+        if not payload.get("ok", False):
+            message = payload.get("error") or "native parser returned no result"
+            return self._fallback_result(codebase, file_record, text, message, kind="parse_failed")
+        return self._convert(codebase, file_record, text, payload)
+
+    def _fallback_result(self, codebase, file_record, text, reason: str, kind: str = "adapter_missing") -> ParseResult:
+        result = self.fallback.parse_file(codebase, file_record, text)
+        result.actual_parser = result.actual_parser or self.fallback.parser_for_file(codebase, file_record)
+        result.diagnostics.append({
+            "codebase": codebase.name,
+            "path": file_record["path"],
+            "line": 1,
+            "severity": "warning",
+            "kind": kind,
+            "message": f"native AST unavailable for {file_record['language']}; {self.fallback.parser_id} fallback used: {reason}",
+            "parser": self.parser_id,
+            "metadata": {
+                "capability": "native_unavailable",
+                "native_parser": self.parser_id,
+                "fallback_parser": self.fallback.parser_id,
+            },
+        })
+        return result
+
+    def _start_process(self, codebase=None) -> subprocess.Popen:
+        command = self.command(codebase)
+        key = self._process_key(codebase, command)
+        current = self._processes.get(key)
+        if current is not None and current.poll() is None:
+            return current
+        process = subprocess.Popen(
+            command,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+            encoding="utf-8",
+            bufsize=1,
+            env={**os.environ, "NO_COLOR": "1"},
+        )
+        self._processes[key] = process
+        return process
+
+    def _process_key(self, codebase=None, command: Optional[List[str]] = None) -> str:
+        actual_command = command if command is not None else self.command(codebase)
+        return f"{self._availability_key(codebase)}\0{json.dumps(actual_command, ensure_ascii=False)}"
+
+    def _request(self, codebase, file_record, text) -> Dict:
+        process = self._start_process(codebase)
+        if self.transport == "base64-tsv":
+            request = "\t".join([
+                base64.b64encode(file_record["path"].encode("utf-8")).decode("ascii"),
+                base64.b64encode(text.encode("utf-8")).decode("ascii"),
+            ])
+        else:
+            request = json.dumps({"path": file_record["path"], "source": text}, ensure_ascii=False)
+        assert process.stdin is not None and process.stdout is not None
+        process.stdin.write(request + "\n")
+        process.stdin.flush()
+        readable, _, _ = select.select([process.stdout], [], [], 30.0)
+        if not readable:
+            raise TimeoutError("native parser timed out after 30 seconds")
+        response = process.stdout.readline()
+        if not response:
+            raise RuntimeError(f"native parser exited with status {process.poll()}")
+        return json.loads(response)
+
+    def _convert(self, codebase, record, text: str, payload: Dict) -> ParseResult:
+        path = record["path"]
+        language = record["language"]
+        content_hash = record["content_hash"]
+        file_symbol = _symbol(
+            codebase.name, language, "file", Path(path).name, path, 1,
+            max(1, len(text.splitlines())), content_hash,
+            qualified_name=path, parser=self.parser_id,
+        )
+        symbols = [file_symbol]
+        by_key: Dict[str, Dict] = {"": file_symbol}
+        pending = list(payload.get("declarations") or [])
+        # Helpers emit parents before children, but tolerate out-of-order data.
+        while pending:
+            remaining = []
+            progressed = False
+            for declaration in pending:
+                parent_key = str(declaration.get("parent") or "")
+                parent = by_key.get(parent_key)
+                if parent is None:
+                    remaining.append(declaration)
+                    continue
+                kind = declaration.get("kind") or "function"
+                name = declaration.get("name") or "anonymous"
+                signature = declaration.get("signature") or ""
+                qualified = declaration.get("qualified_name") or f"{parent['qualified_name']}::{name}"
+                symbol = _symbol(
+                    codebase.name, language, kind, name, path,
+                    max(1, int(declaration.get("line_start") or 1)),
+                    max(1, int(declaration.get("line_end") or declaration.get("line_start") or 1)),
+                    content_hash, qualified_name=qualified, signature=signature[:500],
+                    parser=self.parser_id, visibility=declaration.get("visibility") or "",
+                )
+                symbol["container_id"] = parent["id"]
+                symbol["metadata"].update({"scope_resolution": "native_ast", "native_kind": declaration.get("native_kind", "")})
+                symbols.append(symbol)
+                by_key[str(declaration.get("key"))] = symbol
+                progressed = True
+            if not progressed:
+                # Malformed helper output must not create dangling containers.
+                for declaration in remaining:
+                    declaration["parent"] = ""
+                pending = remaining
+                if pending and all(str(item.get("parent") or "") == "" for item in pending):
+                    continue
+                break
+            pending = remaining
+
+        relations = []
+        for key, symbol in by_key.items():
+            if not key:
+                continue
+            relations.append(_relation(
+                symbol["container_id"] or file_symbol["id"], "contains", path,
+                symbol["line_start"], self.parser_id, "exact", to_id=symbol["id"],
+                metadata={"extraction": "native_ast"},
+            ))
+        for item in payload.get("relations") or []:
+            owner = by_key.get(str(item.get("owner") or ""), file_symbol)
+            target_key = str(item.get("target_key") or "")
+            target = by_key.get(target_key) if target_key else None
+            relations.append(_relation(
+                owner["id"], item.get("type") or "calls", path,
+                max(1, int(item.get("line") or 1)), self.parser_id,
+                item.get("confidence") or "heuristic",
+                to_id=target["id"] if target else "",
+                to_external="" if target else str(item.get("target") or ""),
+                metadata={"extraction": "native_ast", **(item.get("metadata") or {})},
+            ))
+        diagnostics = []
+        for item in payload.get("diagnostics") or []:
+            diagnostics.append({
+                "codebase": codebase.name,
+                "path": path,
+                "line": max(1, int(item.get("line") or 1)),
+                "severity": item.get("severity") or "warning",
+                "kind": item.get("kind") or "parse_failed",
+                "message": item.get("message") or "native parser diagnostic",
+                "parser": self.parser_id,
+            })
+        return ParseResult(symbols=symbols, relations=relations, diagnostics=diagnostics, actual_parser=self.parser_id)
+
+    def _stop_process(self, codebase=None) -> None:
+        if codebase is None:
+            processes = list(self._processes.values())
+            self._processes.clear()
+        else:
+            prefix = f"{self._availability_key(codebase)}\0"
+            keys = [key for key in self._processes if key.startswith(prefix)]
+            processes = [self._processes.pop(key) for key in keys]
+        for process in processes:
+            self._close_process(process)
+
+    @staticmethod
+    def _close_process(process: subprocess.Popen) -> None:
+        try:
+            if process.stdin:
+                process.stdin.close()
+            process.terminate()
+            process.wait(timeout=1)
+        except Exception:
+            process.kill()
+        finally:
+            if process.stdout:
+                process.stdout.close()
+
+    def __del__(self):
+        self._stop_process()
+
+    @staticmethod
+    def _language_for_path(path: Path) -> str:
+        from adapters.generic_text import language_for_path
+        return language_for_path(path)
+
+
+def executable(name: str) -> Tuple[bool, str]:
+    path = shutil.which(name)
+    return (bool(path), path or f"{name} executable not found")
+
+
+class UnavailableNativeAdapter(Adapter):
+    """Explicit native capability gap with a provenance-safe fallback."""
+
+    name = "native-unavailable"
+
+    def __init__(self, language: str, expected_parser: str, fallback: Adapter, reason: str):
+        self.language = language
+        self.expected_parser = expected_parser
+        self.fallback = fallback
+        self.reason = reason
+
+    def version(self) -> str:
+        return "1"
+
+    def parser_for_file(self, codebase, file_record) -> str:
+        return self.fallback.parser_for_file(codebase, file_record)
+
+    def parse_file(self, codebase, file_record, text) -> ParseResult:
+        result = self.fallback.parse_file(codebase, file_record, text)
+        result.actual_parser = result.actual_parser or self.fallback.parser_for_file(codebase, file_record)
+        result.diagnostics.append({
+            "codebase": codebase.name,
+            "path": file_record["path"],
+            "line": 1,
+            "severity": "warning",
+            "kind": "adapter_missing",
+            "message": f"native AST unavailable for {self.language}; {self.fallback.parser_id} fallback used: {self.reason}",
+            "parser": self.parser_id,
+            "metadata": {
+                "capability": "native_unavailable",
+                "expected_parser": self.expected_parser,
+                "fallback_parser": self.fallback.parser_id,
+            },
+        })
+        return result
+
+    def capability(self) -> Dict:
+        return {
+            "parser": self.expected_parser,
+            "languages": [self.language],
+            "native": True,
+            "available": False,
+            "reason": self.reason,
+            "fallback": self.fallback.parser_id,
+        }

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/php_ast.py

@@ -0,0 +1,55 @@
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+from adapters.native_process import HELPER_DIR, NativeProcessAdapter
+
+
+class PhpAstAdapter(NativeProcessAdapter):
+    name = "nikic-php-parser-ast"
+    languages = ("php",)
+    native_description = "nikic PHP-Parser syntax tree; declarations, imports, and calls"
+
+    def __init__(self, fallback):
+        super().__init__(fallback)
+        self.autoload: Optional[Path] = None
+        self.autoload_by_root = {}
+
+    def version(self) -> str:
+        return "1"
+
+    def _autoload_candidates(self, codebase=None):
+        configured = os.environ.get("DEVFLOW_PHP_PARSER_AUTOLOAD")
+        if configured:
+            yield Path(configured)
+        if codebase is not None:
+            yield Path(codebase.root) / "vendor" / "autoload.php"
+            for parent in Path(codebase.root).parents:
+                yield parent / "vendor" / "autoload.php"
+        for parent in Path(__file__).resolve().parents:
+            yield parent / "vendor" / "autoload.php"
+
+    def check_available(self, codebase=None) -> Tuple[bool, str]:
+        php = shutil.which("php")
+        if not php:
+            return False, "php executable not found"
+        for candidate in self._autoload_candidates(codebase):
+            if not candidate.is_file():
+                continue
+            probe = subprocess.run(
+                [php, "-r", f"require {str(candidate)!r}; exit(class_exists('PhpParser\\\\ParserFactory') ? 0 : 3);"],
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False,
+            )
+            if probe.returncode == 0:
+                self.autoload = candidate
+                self.autoload_by_root[self._availability_key(codebase)] = candidate
+                return True, f"nikic/PHP-Parser available via {candidate}"
+        return False, "nikic/PHP-Parser is not installed; set DEVFLOW_PHP_PARSER_AUTOLOAD or install nikic/php-parser"
+
+    def command(self, codebase=None) -> List[str]:
+        autoload = self.autoload_by_root.get(self._availability_key(codebase), self.autoload)
+        if autoload is None:
+            raise RuntimeError("nikic/PHP-Parser autoload path is unavailable")
+        return [shutil.which("php") or "php", str(HELPER_DIR / "php_ast_helper.php"), str(autoload)]

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/python_ast.py

@@ -18,6 +18,15 @@ class PythonAstAdapter(Adapter):
     def version(self) -> str:
         return "1"
 
+    def capability(self) -> Dict:
+        return {
+            "parser": self.parser_id,
+            "languages": ["python"],
+            "native": True,
+            "available": True,
+            "scope": "Python standard library ast syntax tree; declarations, imports, and calls",
+        }
+
     def parse_file(self, codebase, file_record, text) -> ParseResult:
         if file_record["language"] != "python":
             return self.fallback.parse_file(codebase, file_record, text)
@@ -44,6 +53,7 @@ class PythonAstAdapter(Adapter):
             symbols=[file_symbol, *visitor.symbols],
             relations=visitor.contains + visitor.relations,
             diagnostics=[],
+            actual_parser=self.parser_id,
         )
 
 

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/registry.py

@@ -1,6 +1,41 @@
 from .generic_text import GenericTextAdapter
+from .go_ast import GoAstAdapter
+from .java_ast import JavaAstAdapter
+from .native_process import UnavailableNativeAdapter
+from .php_ast import PhpAstAdapter
 from .python_ast import PythonAstAdapter
 from .structured_scope import StructuredScopeAdapter
+from .typescript_ast import TypeScriptAstAdapter
+
+
+UNAVAILABLE_NATIVE = {
+    "ruby": ("prism-ast", "Ruby Prism integration is not installed"),
+    "rust": ("rust-analyzer-ast", "rust-analyzer/syn integration is not installed"),
+    "kotlin": ("kotlin-psi-ast", "Kotlin PSI/compiler integration is not installed"),
+    "c": ("clang-ast", "Clang libTooling integration is not installed"),
+    "cpp": ("clang-ast", "Clang libTooling integration is not installed"),
+    "csharp": ("roslyn-ast", "Roslyn integration is not installed"),
+    "swift": ("swift-syntax-ast", "SwiftSyntax integration is not installed"),
+    "dart": ("dart-analyzer-ast", "Dart analyzer integration is not installed"),
+    "scala": ("scalameta-ast", "Scalameta integration is not installed"),
+    "lua": ("tree-sitter-lua-ast", "tree-sitter-lua integration is not installed"),
+    "shell": ("tree-sitter-bash-ast", "tree-sitter-bash integration is not installed"),
+    "vue": ("vue-compiler-ast", "Vue compiler integration is not installed"),
+    "svelte": ("svelte-compiler-ast", "Svelte compiler integration is not installed"),
+    "sql": ("sqlglot-ast", "SQLGlot integration is not installed"),
+    "html": ("html-parser-ast", "HTML syntax adapter is not installed"),
+    "css": ("postcss-ast", "PostCSS integration is not installed"),
+    "json": ("json-syntax-tree", "JSON syntax adapter is not installed"),
+    "yaml": ("yaml-syntax-tree", "YAML syntax adapter is not installed"),
+    "toml": ("toml-syntax-tree", "TOML syntax adapter is not installed"),
+    "xml": ("xml-syntax-tree", "XML syntax adapter is not installed"),
+    "graphql": ("graphql-ast", "GraphQL parser integration is not installed"),
+    "protobuf": ("protobuf-parser-ast", "Protobuf parser integration is not installed"),
+    "hcl": ("hcl-parser-ast", "HCL parser integration is not installed"),
+    "terraform": ("hcl-parser-ast", "HCL parser integration is not installed"),
+    "dockerfile": ("dockerfile-parser-ast", "Dockerfile parser integration is not installed"),
+    "markdown": ("markdown-parser-ast", "Markdown syntax adapter is not installed"),
+}
 
 
 class AdapterRegistry:
@@ -8,61 +43,42 @@ class AdapterRegistry:
         self.python = PythonAstAdapter()
         self.structured = StructuredScopeAdapter()
         self.generic = GenericTextAdapter()
-        self.adapters = [self.python, self.structured, self.generic]
-
-        # Keep language selection explicit.  The parser implementation is
-        # conservative and shared for now, but every supported language has a
-        # deliberate registration instead of silently falling through to text
-        # regexes.  This is the extension point for native AST adapters.
+        self.typescript = TypeScriptAstAdapter(self.structured)
+        self.go = GoAstAdapter(self.structured)
+        self.php = PhpAstAdapter(self.structured)
+        self.java = JavaAstAdapter(self.structured)
+        self.native_adapters = [self.python, self.typescript, self.go, self.php, self.java]
+        self.adapters = [*self.native_adapters, self.structured, self.generic]
         self.language_adapters = {
             "python": self.python,
-            "typescript": self.structured,
-            "javascript": self.structured,
-            "ruby": self.structured,
-            "go": self.structured,
-            "rust": self.structured,
-            "php": self.structured,
-            "java": self.structured,
-            "kotlin": self.structured,
-            "c": self.structured,
-            "cpp": self.structured,
-            "csharp": self.structured,
-            "swift": self.structured,
-            "dart": self.structured,
-            "scala": self.structured,
-            "lua": self.structured,
-            "shell": self.structured,
-            "vue": self.structured,
-            "svelte": self.structured,
-            # Data, configuration, and template types are explicitly registered too. They
-            # currently use the safe text adapter until a native parser is
-            # available; this keeps their parser provenance explicit and the
-            # unified output contract unchanged.
-            "sql": self.generic,
-            "html": self.generic,
-            "css": self.generic,
-            "json": self.generic,
-            "yaml": self.generic,
-            "toml": self.generic,
-            "xml": self.generic,
-            "graphql": self.generic,
-            "protobuf": self.generic,
-            "hcl": self.generic,
-            "terraform": self.generic,
-            "dockerfile": self.generic,
-            "markdown": self.generic,
+            "typescript": self.typescript,
+            "javascript": self.typescript,
+            "go": self.go,
+            "php": self.php,
+            "java": self.java,
         }
+        structured_languages = {
+            "ruby", "rust", "kotlin", "c", "cpp", "csharp", "swift",
+            "dart", "scala", "lua", "shell", "vue", "svelte",
+        }
+        for language, (expected, reason) in UNAVAILABLE_NATIVE.items():
+            fallback = self.structured if language in structured_languages else self.generic
+            self.language_adapters[language] = UnavailableNativeAdapter(language, expected, fallback, reason)
 
     def adapter_for_file(self, codebase, file_record):
         language = file_record.get("language")
-        return self.language_adapters.get(language, self.generic)
+        return self.language_adapters.get(
+            language,
+            UnavailableNativeAdapter(language or "unknown", "unregistered-native-ast", self.generic, "no native adapter is registered"),
+        )
 
     def adapters_for(self, codebase, files, manifests):
-        scored = []
-        for adapter in self.adapters:
-            score = adapter.detect(codebase, files, manifests)
-            if score > 0:
-                scored.append((score, adapter))
-        if not scored:
-            return [GenericTextAdapter()]
-        return [adapter for _, adapter in sorted(scored, key=lambda item: item[0], reverse=True)]
+        return [self.adapter_for_file(codebase, {"language": self._language(path)}) for path in files]
+
+    def capabilities(self):
+        return {language: adapter.capability() for language, adapter in sorted(self.language_adapters.items())}
+
+    @staticmethod
+    def _language(path):
+        from .generic_text import language_for_path
+        return language_for_path(path)

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/structured_scope.py

@@ -127,7 +127,7 @@ class StructuredScopeAdapter(Adapter):
             for target in _extract_calls(line, record["language"]):
                 receiver = bool(re.search(rf"\.\s*{re.escape(target)}\s*\(", line))
                 relations.append(_relation(owner, "calls", record["path"], number, self.parser_id, "heuristic", to_external=f"call:{target}", metadata={"resolution": "receiver_unresolved" if receiver else "name_only", "allow_unique_name_resolution": not receiver, "dynamic_limitations": True}))
-        return ParseResult(symbols=[file_symbol, *symbols], relations=relations, diagnostics=[])
+        return ParseResult(symbols=[file_symbol, *symbols], relations=relations, diagnostics=[], actual_parser=self.parser_id)
 
 
 def _without_strings_and_comments(line: str) -> str:

package/plugins/devflow-intel/skills/workflow-code-index/scripts/adapters/typescript_ast.py

@@ -0,0 +1,31 @@
+import shutil
+import subprocess
+from pathlib import Path
+from typing import List, Tuple
+
+from adapters.native_process import HELPER_DIR, NativeProcessAdapter
+
+
+class TypeScriptAstAdapter(NativeProcessAdapter):
+    name = "typescript-compiler-ast"
+    languages = ("typescript", "javascript")
+    native_description = "TypeScript Compiler API syntax tree; declarations, imports, and calls"
+
+    def version(self) -> str:
+        return "1"
+
+    def check_available(self, codebase=None) -> Tuple[bool, str]:
+        node = shutil.which("node")
+        if not node:
+            return False, "node executable not found"
+        helper = HELPER_DIR / "typescript_ast_helper.cjs"
+        probe = subprocess.run(
+            [node, "-e", "require.resolve('typescript')"], cwd=str(helper.parent),
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False,
+        )
+        if probe.returncode != 0:
+            return False, "typescript compiler API module not found"
+        return True, "typescript compiler API available"
+
+    def command(self, codebase=None) -> List[str]:
+        return [shutil.which("node") or "node", str(HELPER_DIR / "typescript_ast_helper.cjs")]

package/plugins/devflow-intel/skills/workflow-code-index/scripts/code_index.py

@@ -99,7 +99,7 @@ def _publish_snapshot(staging: Path, output: Path, counts: Dict[str, int], works
         os.close(directory_fd)
 
 
-def _workspace_state(root: Path, files: List[dict], changed: Set[str], discovered_paths: Iterable[str] | None = None) -> Dict[str, object]:
+def _workspace_state(root: Path, files: List[dict], changed: Set[str], discovered_paths: Iterable[str] | None = None, capabilities: Dict[str, object] | None = None) -> Dict[str, object]:
     indexed_paths = sorted(record["path"] for record in files)
     discovered = sorted(set(discovered_paths or indexed_paths))
     source_manifest_hash = _hash_lines(f"{record['path']}\0{record['content_hash']}" for record in files)
@@ -112,11 +112,7 @@ def _workspace_state(root: Path, files: List[dict], changed: Set[str], discovere
         "dirtyPathsAtBuild": sorted(changed),
         "extractors": extractors,
         "extractorSetHash": _hash_lines(extractors),
-        "capabilities": {
-            "python-ast@1": {"scope": "exact syntax tree", "targets": "lexical names; dynamic dispatch unresolved"},
-            "structured-scope@1": {"scope": "inferred lexical braces/end blocks", "targets": "name-only heuristic"},
-            "generic-text@2": {"scope": "file-level", "targets": "heuristic only"},
-        },
+        "capabilities": capabilities or {},
     }
 
 
@@ -290,8 +286,9 @@ def command_scan(args) -> int:
                         "parser": "pending",
                     }
                     adapter = registry.adapter_for_file(codebase, file_record)
-                    file_record["parser"] = adapter.parser_id
+                    file_record["parser"] = adapter.parser_for_file(codebase, file_record)
                     result = adapter.parse_file(codebase, file_record, text)
+                    file_record["parser"] = result.actual_parser or file_record["parser"]
                     files.append(file_record)
                     symbols.extend(result.symbols)
                     relations.extend(result.relations)
@@ -319,7 +316,7 @@ def command_scan(args) -> int:
         staging = Path(tempfile.mkdtemp(prefix=f".{output.name}.build-", dir=str(output.parent)))
         try:
             generation = str(uuid.uuid4())
-            workspace_state = _workspace_state(root, files, changed, discovered_paths)
+            workspace_state = _workspace_state(root, files, changed, discovered_paths, registry.capabilities())
             workspace_state["generatedAt"] = datetime.now(timezone.utc).isoformat()
             workspace_state["semanticExtractor"] = SEMANTIC_EXTRACTOR_VERSION
             workspace_state["extractorSetHash"] = _hash_lines([*workspace_state.get("extractors", []), SEMANTIC_EXTRACTOR_VERSION])

package/plugins/devflow-intel/skills/workflow-code-index/scripts/semantic.py

@@ -19,11 +19,14 @@ def build_semantic_facts(root: Path, files: Iterable[dict], symbols: Iterable[di
     entities: List[dict] = []
     flows: List[dict] = []
     bindings: List[dict] = []
+    records = list(files)
     symbol_by_path = {}
     for symbol in symbols:
         symbol_by_path.setdefault(symbol.get("path"), []).append(symbol)
 
-    for file_record in files:
+    for file_number, file_record in enumerate(records, 1):
+        if file_number == 1 or file_number % 250 == 0 or file_number == len(records):
+            print(f"[code-index][semantic] processed {file_number}/{len(records)} files", flush=True)
         path = file_record["path"]
         source = _read(root, path)
         if source is None:
@@ -45,10 +48,11 @@ def build_semantic_facts(root: Path, files: Iterable[dict], symbols: Iterable[di
                 if symbol.get("kind") in {"route", "component", "class", "function", "method"}:
                     bindings.append(_binding(feature_id, symbol["id"], "static_inferred", "heuristic", path, symbol.get("line_start", 1)))
 
+        state_ids = set()
         for line_no, line in enumerate(source.splitlines(), 1):
             _extract_api(line, path, file_record, line_no, entities, flows)
             _extract_db(line, path, file_record, line_no, entities, flows)
-            _extract_ui(line, path, file_record, line_no, entities, flows)
+            _extract_ui(line, path, file_record, line_no, entities, flows, state_ids)
 
     # Existing structural relations remain the source of method call edges;
     # expose them in the semantic graph without changing their meaning.
@@ -110,7 +114,8 @@ def _extract_db(line, path, record, line_no, entities, flows):
         flows.append(_flow(table_id, column_id, f"{operation}_column", path, line_no, "heuristic", "sql_column_regex"))
 
 
-def _extract_ui(line, path, record, line_no, entities, flows):
+def _extract_ui(line, path, record, line_no, entities, flows, state_ids=None):
+    state_ids = state_ids if state_ids is not None else set()
     component = re.search(r"\b(?:function|class)\s+([A-Z][A-Za-z0-9_]*)|<([A-Z][A-Za-z0-9_.]*)\b", line)
     state = re.search(r"\b(?:useState|ref|reactive|computed|createSignal)\s*\(.*?\)|\b(?:const|let|var)\s+([A-Za-z_][\w]*(?:State|Store|Status|Loading|Error))\s*=", line)
     condition = re.search(r"\b(?:v-if|v-show)\s*=\s*['\"]([^'\"]+)['\"]|(?:\{\s*)?([^{}\n]+?)\s*&&\s*<", line)
@@ -125,16 +130,16 @@ def _extract_ui(line, path, record, line_no, entities, flows):
         name = state.group(1) or "anonymous_state"
         state_id = f"ui-state:{stable_key(path)}:{stable_key(name)}"
         entities.append(_entity(state_id, "ui_state", name, record, line_no, line_no, "heuristic", "state_pattern"))
+        state_ids.add(state_id)
         flows.append(_flow(component_id, state_id, "state_reads", path, line_no, "heuristic", "state_pattern"))
     if condition:
         expression = condition.group(1) or condition.group(2)
         cond_id = f"render-condition:{stable_key(path)}:{short_hash(expression)}"
         entities.append(_entity(cond_id, "render_condition", expression, record, line_no, line_no, "heuristic", "template_condition"))
         flows.append(_flow(component_id, cond_id, "renders_when", path, line_no, "heuristic", "template_condition"))
-        known_ids = {item["id"] for item in entities if item.get("entity_type") == "ui_state"}
         for name in re.findall(r"\b[A-Za-z_][A-Za-z0-9_]*\b", expression):
             state_id = f"ui-state:{stable_key(path)}:{stable_key(name)}"
-            if state_id in known_ids:
+            if state_id in state_ids:
                 flows.append(_flow(cond_id, state_id, "depends_on", path, line_no, "heuristic", "condition_identifier"))
 
 

package/src/constants.ts

@@ -1,5 +1,5 @@
 export const PRODUCT_NAME = "Devflow Pi";
-export const PRODUCT_VERSION = "0.1.75";
+export const PRODUCT_VERSION = "0.1.77";
 export const PROJECT_SCHEMA_VERSION = 1;
 export const OMP_RUNTIME_VERSION = "17.2.7";
 

package/src/initialization-store.ts

@@ -455,6 +455,17 @@ export class InitializationStore {
     return this.db.query("UPDATE initialization_runs SET status='cancelled',updated_at=? WHERE id=? AND lease_token=? AND lease_expires_at>? AND status IN ('preparing','collecting','validating')").run(timestamp, runId, leaseToken, timestamp).changes === 1;
   }
 
+  /** Operator cancellation invalidates the worker lease so a detached worker cannot publish later. */
+  cancelRunByOperator(runId: string, reason = "cancelled by operator"): boolean {
+    const replacementLease = randomUUID();
+    const result = this.db.query(`UPDATE initialization_runs
+      SET status='cancelled', lease_token=?, error=?, updated_at=?
+      WHERE id=? AND status IN ('preparing','collecting','validating')`).run(
+      replacementLease, reason.slice(0, 4000), now(), runId,
+    );
+    return result.changes === 1;
+  }
+
   failRun(runId: string, leaseToken: string, error: string): boolean {
     this.assertWritableRun(runId, leaseToken);
     const timestamp = now();