refactor: restructure project layout and add install.mjs

- Move src/ → plugin/ with subdirectories:
  - plugin/core/ (business logic, models, store, permissions, utils, memory)
  - plugin/tools/ (query, resources)
  - plugin/commands/ (placeholder for slash commands)
  - plugin/hooks/ (placeholder for lifecycle hooks)
  - plugin/index.ts (wiring layer only, no business logic)
- Add install.mjs with --install, --uninstall, --openclaw-profile-path
- Add skills/ and docs/ root directories
- Move planning docs (PLAN.md, FEAT.md, AGENT_TASKS.md) to docs/
- Remove old scripts/install.sh
- Update tsconfig rootDir: src → plugin
- Update README.md and README.zh.md with new layout
- Bump version to 0.2.0
- All tests pass

plugin/tools/query.ts

@@ -0,0 +1,75 @@
+import { YonexusError } from '../core/models/errors';
+import type { Identity, QueryFilter, QueryInput, QueryOptions, YonexusSchema } from "../core/models/types";
+
+const DEFAULT_LIMIT = 20;
+const MAX_LIMIT = 100;
+
+const regexCache = new Map<string, RegExp>();
+const containsCache = new Map<string, string>();
+
+function getRegex(pattern: string): RegExp {
+  const cached = regexCache.get(pattern);
+  if (cached) return cached;
+  const created = new RegExp(pattern);
+  regexCache.set(pattern, created);
+  return created;
+}
+
+function normalizeNeedle(value: string): string {
+  const cached = containsCache.get(value);
+  if (cached) return cached;
+  const normalized = value.toLowerCase();
+  containsCache.set(value, normalized);
+  return normalized;
+}
+
+function isQueryable(field: string, schema: YonexusSchema): boolean {
+  return Boolean(schema[field]?.queryable);
+}
+
+function matchFilter(identity: Identity, filter: QueryFilter): boolean {
+  const raw = identity.meta[filter.field] ?? "";
+
+  switch (filter.op) {
+    case "eq":
+      return raw === filter.value;
+    case "contains":
+      return raw.toLowerCase().includes(normalizeNeedle(filter.value));
+    case "regex": {
+      const re = getRegex(filter.value);
+      return re.test(raw);
+    }
+    default:
+      return false;
+  }
+}
+
+function normalizeOptions(options?: QueryOptions): Required<QueryOptions> {
+  const limit = Math.min(Math.max(1, options?.limit ?? DEFAULT_LIMIT), MAX_LIMIT);
+  const offset = Math.max(0, options?.offset ?? 0);
+  return { limit, offset };
+}
+
+function sortFilters(filters: QueryFilter[]): QueryFilter[] {
+  const weight = (f: QueryFilter): number => {
+    if (f.op === 'eq') return 1;
+    if (f.op === 'contains') return 2;
+    return 3;
+  };
+  return [...filters].sort((a, b) => weight(a) - weight(b));
+}
+
+export function queryIdentities(identities: Identity[], input: QueryInput, schema: YonexusSchema): Identity[] {
+  for (const filter of input.filters) {
+    if (!isQueryable(filter.field, schema)) {
+      throw new YonexusError('FIELD_NOT_QUERYABLE', `field_not_queryable: ${filter.field}`, {
+        field: filter.field
+      });
+    }
+  }
+
+  const orderedFilters = sortFilters(input.filters);
+  const filtered = identities.filter((identity) => orderedFilters.every((f) => matchFilter(identity, f)));
+  const { limit, offset } = normalizeOptions(input.options);
+  return filtered.slice(offset, offset + limit);
+}

plugin/tools/resources.ts

@@ -0,0 +1,111 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { YonexusError } from '../core/models/errors';
+import type { DocsScope, DocsTopic } from '../core/models/types';
+import { slug } from '../core/utils/id';
+
+const TOPICS: DocsTopic[] = ['docs', 'notes', 'knowledge', 'rules', 'lessons', 'workflows'];
+
+function ensureDirs(base: string, dirs: string[]): void {
+  for (const d of dirs) fs.mkdirSync(path.join(base, d), { recursive: true });
+}
+
+export class ResourceLayout {
+  constructor(private readonly rootDir: string) {}
+
+  get organizationsRoot(): string {
+    return path.join(this.rootDir, 'organizations');
+  }
+
+  orgPath(orgName: string): string {
+    return path.join(this.organizationsRoot, slug(orgName));
+  }
+
+  teamPath(orgName: string, teamName: string): string {
+    return path.join(this.orgPath(orgName), 'teams', slug(teamName));
+  }
+
+  agentPath(orgName: string, teamName: string, agentId: string): string {
+    return path.join(this.teamPath(orgName, teamName), 'agents', slug(agentId));
+  }
+
+  ensureOrganization(orgName: string): void {
+    const root = this.orgPath(orgName);
+    ensureDirs(root, ['teams', ...TOPICS]);
+  }
+
+  ensureTeam(orgName: string, teamName: string): void {
+    const root = this.teamPath(orgName, teamName);
+    ensureDirs(root, ['agents', ...TOPICS]);
+  }
+
+  ensureAgent(orgName: string, teamName: string, agentId: string): void {
+    const root = this.agentPath(orgName, teamName, agentId);
+    ensureDirs(root, TOPICS);
+  }
+
+  private readTopicFiles(topicRoot: string, keyword: string): string[] {
+    if (!fs.existsSync(topicRoot)) return [];
+    let re: RegExp;
+    try {
+      re = new RegExp(keyword);
+    } catch {
+      throw new YonexusError('VALIDATION_ERROR', 'invalid_regex', { keyword });
+    }
+
+    const entries = fs.readdirSync(topicRoot, { withFileTypes: true });
+    return entries
+      .filter((e) => e.isFile() && re.test(e.name))
+      .map((e) => path.join(topicRoot, e.name));
+  }
+
+  getDocs(scope: DocsScope, topic: DocsTopic, keyword: string): string {
+    const groups: Record<'ORG' | 'DEPT' | 'TEAM' | 'AGENT', string[]> = {
+      ORG: [],
+      DEPT: [],
+      TEAM: [],
+      AGENT: []
+    };
+
+    const orgsRoot = this.organizationsRoot;
+    if (!fs.existsSync(orgsRoot)) {
+      return '----ORG\n----DEPT\n----TEAM\n----AGENT';
+    }
+
+    const orgs = fs.readdirSync(orgsRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+
+    for (const orgName of orgs) {
+      const orgPath = path.join(orgsRoot, orgName);
+      if (scope === 'organization') {
+        groups.ORG.push(...this.readTopicFiles(path.join(orgPath, topic), keyword));
+      }
+
+      const teamsRoot = path.join(orgPath, 'teams');
+      if (!fs.existsSync(teamsRoot)) continue;
+
+      const teams = fs.readdirSync(teamsRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      for (const teamName of teams) {
+        const teamPath = path.join(teamsRoot, teamName);
+        if (scope === 'team') {
+          groups.TEAM.push(...this.readTopicFiles(path.join(teamPath, topic), keyword));
+        }
+
+        const agentsRoot = path.join(teamPath, 'agents');
+        if (!fs.existsSync(agentsRoot)) continue;
+
+        const agents = fs.readdirSync(agentsRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+        for (const agentId of agents) {
+          if (scope === 'agent') {
+            groups.AGENT.push(...this.readTopicFiles(path.join(agentsRoot, agentId, topic), keyword));
+          }
+        }
+      }
+    }
+
+    // department folders are not defined in this layout; reserved empty group for compatible output.
+    const printGroup = (k: 'ORG' | 'DEPT' | 'TEAM' | 'AGENT'): string =>
+      [`----${k}`, ...groups[k]].join('\n');
+
+    return [printGroup('ORG'), printGroup('DEPT'), printGroup('TEAM'), printGroup('AGENT')].join('\n');
+  }
+}