agentlas 1.0.15 → 1.0.17

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 1.0.17 — 2026-07-31
+
+- **Terminal requires the verification-aware Context Map engine.** Context
+  commands now select Agentlas OS 1.1.86 or newer, whose impact graph connects
+  code changes to tests, test commands, CI workflows, and product-version
+  contracts, including local test files intentionally excluded from Git.
+- A stale Core can no longer satisfy the Terminal context capability merely by
+  exposing the old module path; the version gate fails closed before execution.
+
+## 1.0.16 — 2026-07-30
+
+- **Project-scoped plugin listing now fails closed.** A missing, unsafe, or
+  uninitialized `--project` path returns a clear error instead of silently
+  showing the global Hub catalog as if project compatibility had been checked.
+- Plugin listing names its actual scope: the global Hub catalog does not claim
+  to evaluate project compatibility or local installation state.
+- Unknown, conflicting, or incomplete plugin flags now return usage errors
+  instead of being ignored.
+
 ## 1.0.15 — 2026-07-29
 
 - **Agent Cloud saves work from a new machine or fresh clone.** Before writing,

package/engine/agentlas-core-harness.cjs

@@ -10,7 +10,7 @@ const { compareSemVer, normalizeSemVer } = require("./semver.cjs");
 const HARNESS_SCHEMA_VERSION = "agentlas.stormbreaker.goal-ultracode-harness.v1";
 const HARNESS_ID = "agentlas-core/stormbreaker-goal-ultracode";
 const HARNESS_MODE = "stormbreaker-goal-ultracode";
-const CONTEXT_MAP_MIN_CORE_VERSION = "1.1.66";
+const CONTEXT_MAP_MIN_CORE_VERSION = "1.1.86";
 const CORE_MANIFEST_MAX_BYTES = 64 * 1024;
 const CORE_RUNTIME_MARKERS = [
   ["agentlas_cloud", "__main__.py"],

package/engine/agentlas-workforce.cjs

@@ -142,13 +142,14 @@ const HUB_SECRET_PATTERNS = [
   ["credential_assignment", /\b(?:api[_-]?key|access[_-]?key|client[_-]?secret|secret|token|password|passwd|cookie)\s*[:=]\s*['"]?[^\s'";,]{8,}/i],
   ["credential_url", /\b[A-Za-z][A-Za-z0-9+.-]*:\/\/[^\s/:@]+:[^\s/@]+@[^\s/]+/i],
 ];
-const WORKFORCE_ONTOLOGY_MENU = [
-  "Controlled communities: community:software-engineering, community:backend-engineering, community:frontend-engineering, community:database-engineering, community:payments-engineering, community:quality-engineering, community:security-engineering, community:data-engineering, community:ai-engineering, community:devops, community:product-design, community:research, community:marketing, community:finance, community:corporate-development, community:insurance, community:insurance-actuarial, community:insurance-claims, community:insurance-underwriting, community:human-resources, community:information-technology, community:legal, community:travel, community:operations, community:agent-systems.",
-  "Controlled roles: role:software-architect, role:backend-engineer, role:frontend-engineer, role:database-engineer, role:payments-engineer, role:quality-engineer, role:security-engineer, role:ontology-architect, role:agent-runtime-engineer, role:researcher, role:ma-diligence-lead, role:insurance-actuary, role:claims-diligence-specialist, role:underwriting-diligence-specialist, role:travel-planner.",
-  "Canonical skills: skill:software-architecture, skill:api-design, skill:server-implementation, skill:frontend-implementation, skill:data-modeling, skill:database-querying, skill:billing-integration, skill:transaction-integrity, skill:test-design, skill:verification, skill:security-review, skill:ontology-modeling, skill:knowledge-graph-design, skill:multi-agent-orchestration, skill:runtime-integration, skill:evidence-synthesis, skill:deal-diligence, skill:valuation, skill:actuarial-reserving, skill:solvency-analysis, skill:claims-liability-assessment, skill:underwriting-portfolio-analysis, skill:travel-planning.",
-  "Canonical tool capabilities: tool:file-system, tool:file-read, tool:file-write, tool:shell, tool:web-search, tool:browser, tool:mongodb, tool:database, tool:github, tool:payments.",
-  "Use artifact:<kind> for consumes, produces and edge artifactKinds. consumes and produces are hard candidate-profile declaration gates: list an artifact there only when the Hub package itself must declare that exact input/output capability. Put ordinary workflow inputs, outputs, and handoffs in the slot task and edges.artifactKinds instead. Default requiredRoles to an empty array. There is no optionalRoles field: express desired role fit through title, task, optionalCommunities, and optionalSkills. Require an exact controlled role only when a candidate lacking that exact declared role could not execute the assignment; never invent a near-synonym role ID.",
-  "Treat required roles, skills, tools, artifacts and authorities as non-negotiable hard constraints only when Hub package declarations must prove them. Legacy Hub profiles can legitimately have empty role/tool fields. Use a broad required community for the job-family boundary, put desired expertise in optional communities/skills plus the role task, and let the host LLM judge title, summary and semantic evidence.",
+const WORKFORCE_ONTOLOGY_GUIDE = [
+  "Roles, communities, skills and knowledge are open-world English semantic IDs. Seed values are aliases and graph anchors, never allowlists. Author a new faithful namespaced ID when no seed expresses the work.",
+  "Community seed examples: community:software-engineering, community:backend-engineering, community:frontend-engineering, community:database-engineering, community:payments-engineering, community:quality-engineering, community:security-engineering, community:data-engineering, community:ai-engineering, community:devops, community:product-design, community:research, community:marketing, community:finance, community:legal, community:travel, community:operations, community:agent-systems.",
+  "Role seed examples: role:software-architect, role:backend-engineer, role:frontend-engineer, role:database-engineer, role:payments-engineer, role:quality-engineer, role:security-engineer, role:ontology-architect, role:agent-runtime-engineer, role:researcher, role:travel-planner.",
+  "Skill seed examples: skill:software-architecture, skill:api-design, skill:server-implementation, skill:frontend-implementation, skill:data-modeling, skill:test-design, skill:verification, skill:ontology-modeling, skill:knowledge-graph-design, skill:evidence-synthesis, skill:travel-planning.",
+  "Tool capability seed examples: tool:file-system, tool:file-read, tool:file-write, tool:shell, tool:web-search, tool:browser, tool:mongodb, tool:database, tool:github, tool:payments. Tool binding remains a prepare-time runtime concern.",
+  "Use artifact:<kind> only for edges.artifactKinds. Do not fill consumes, produces, requiredRoles, requiredToolCapabilities, requiredAuthorities, forbiddenAuthorities, or modalities on a slot — tools, authorities, and modalities attach to the executing runtime, not the agent card, and card-declaration gates on those fields only exclude real candidates. Put ordinary workflow inputs, outputs, and handoffs in the slot task and edges.artifactKinds. Express desired role fit through title, task, optionalCommunities, and optionalSkills.",
+  "Use a broad required community for the job-family boundary, put desired expertise in optional communities/skills plus the role task, and let the host LLM judge title, summary and semantic evidence.",
   "forbiddenCommunities and excludedCommunities are not exhaustive lists of every unused job family. Add only an explicit user prohibition or an inherent incompatibility with the assignment. Never forbid a broad ancestor, descendant, adjacent, or legitimately co-occurring community merely because another community was selected.",
 ].join("\n");
 
@@ -1013,6 +1014,23 @@ function validateWorkOrder(value) {
   }
   const slots = assertArray(order.roleSlots, "workOrder.roleSlots", MAX_SLOTS, { min: 1 });
   const seen = new Set();
+  // An absent list-valued slot field IS the empty constraint (2026-07-30):
+  // normalize (absent -> []) BEFORE validation and before the order is
+  // digested or sent, so a lean-form author and a full-form author produce
+  // byte-identical canonical orders. Full forms pass through untouched.
+  const SLOT_LIST_FIELDS = [
+    "requiredCommunities", "optionalCommunities", "excludedCommunities",
+    "requiredRoles", "requiredSkills", "optionalSkills", "requiredKnowledge",
+    "requiredToolCapabilities", "consumes", "produces", "requiredAuthorities",
+    "forbiddenAuthorities", "runtimes", "languages", "modalities",
+  ];
+  for (let index = 0; index < slots.length; index += 1) {
+    if (slots[index] && typeof slots[index] === "object" && !Array.isArray(slots[index])) {
+      for (const field of SLOT_LIST_FIELDS) {
+        if (!Object.prototype.hasOwnProperty.call(slots[index], field)) slots[index][field] = [];
+      }
+    }
+  }
   for (let index = 0; index < slots.length; index += 1) {
     const slot = assertObject(slots[index], `roleSlots[${index}]`);
     assertExactKeys(slot, [
@@ -1850,14 +1868,14 @@ function buildPrompts(task, identity) {
     "Return the direct agentlas.workforce-work-order.v1 JSON object. Do not emit schemaVersion=agentlas.workforce-leader-call.v1 and do not emit toolCall, name, or arguments wrappers. The host invokes workforce.search_candidates with your exact validated WorkOrder.",
     "The direct WorkOrder top level must contain exactly: schemaVersion, workOrderId, taskBrief, redacted, ontologyVersion, roleSlots, edges, forbiddenCommunities, selectionPolicy.",
     `Exact direct WorkOrder example: ${stableJson(workOrderShape)}`,
-    "Every roleSlots item must contain exactly slotId, title, task, cardinality, criticality, requiredCommunities, optionalCommunities, excludedCommunities, requiredRoles, requiredSkills, optionalSkills, requiredKnowledge, requiredToolCapabilities, consumes, produces, requiredAuthorities, forbiddenAuthorities, runtimes, languages, modalities, and allowedEntityKinds; minimumEvidenceLevel is the only optional extra key. Empty arrays must still be present; the host will not add them.",
-    "consumes and produces are hard eligibility fields matched against exact candidate-profile declarations. Do not use them for ordinary project workflow. Describe normal inputs/outputs in task and represent inter-slot handoffs with edges and edges.artifactKinds.",
+    "Every roleSlots item must contain slotId, title, task, cardinality, criticality, and allowedEntityKinds; minimumEvidenceLevel is optional. Constrain the hire only through requiredCommunities, optionalCommunities, excludedCommunities, requiredSkills, optionalSkills, requiredKnowledge, runtimes, and languages, and only when the constraint is genuine. Any list field you leave out is the empty constraint — the host normalizes absent to [] before validation and digest, so omit empty ones instead of spelling [].",
+    "Never fill requiredToolCapabilities, requiredAuthorities, forbiddenAuthorities, consumes, produces, requiredRoles, or modalities: tools, authorities, and modalities attach to the executing runtime, not the agent card, and those gates only exclude real candidates. Describe normal inputs/outputs in task and represent inter-slot handoffs with edges and edges.artifactKinds.",
     "workOrderId and every concept/reference id must match [A-Za-z0-9][A-Za-z0-9._:/@-]{1,255} and have total length at most 255 characters. taskBrief is limited to 64000 characters; each slot title to 160 and slot task to 32000 — describe each responsibility as fully as the work honestly needs. Each id array is limited to 256 unique items.",
     "roleSlots must contain 1-32 items. cardinality must be an integer from 1 through 16. criticality must be exactly required or optional. allowedEntityKinds must be a non-empty unique subset of executable agent, team. group is ontology/discovery metadata and cannot be executed. minimumEvidenceLevel, when authored, must be exactly declared, checked, demonstrated, or attested.",
     "edges must contain at most 128 items. Every edge must contain exactly from, to, relation, and artifactKinds. from and to must reference declared slotId values. relation must be exactly one of reportsTo, handsOffTo, reviews, coordinatesWith.",
     "forbiddenCommunities and edges must be explicitly authored arrays. selectionPolicy must contain exactly allowHistoryEvidence=false, integer minimumCandidatesPerSlot from 2 through 30, and integer maximumCandidatesPerSlot from 2 through 100 that is not below the minimum.",
     "A community cannot appear in forbiddenCommunities or a slot's excludedCommunities when that same slot requires or optionally prefers it. Also avoid broader ancestor, descendant, adjacent, and legitimately co-occurring exclusions; the host rejects exact contradictions but does not invent ontology lineage or mutate your decision.",
-    `redacted must be true and ontologyVersion must be exactly ${WORKFORCE_ONTOLOGY_VERSION}. Do not invent controlled concept IDs.`,
+    `redacted must be true and ontologyVersion must be exactly ${WORKFORCE_ONTOLOGY_VERSION}; this pins graph semantics, not a finite vocabulary. Write all discovery-facing content in English and use faithful open namespaced concept IDs.`,
   ].join("\n");
   const selectionSchemaRequirements = [
     "Return the direct agentlas.workforce-selection.v1 JSON object. Do not emit schemaVersion=agentlas.workforce-leader-call.v1 and do not emit toolCall, name, or arguments wrappers. The host invokes workforce.validate_selection with your exact validated Selection.",
@@ -1887,15 +1905,14 @@ function buildPrompts(task, identity) {
       "Any specialized domain explicitly present in the task with distinct failure or accountability semantics must have its own accountable domain slot. Examples include payments, insurance, legal, finance, travel, and regulated science or operations. Never collapse such a named domain into generic backend, software, database, or implementation work. This is a general job-analysis rule, not a fixed list of required professions.",
       "forbiddenCommunities is not the inverse of selected communities and not an exhaustive list of unused professions. Add a global or slot exclusion only when the user explicitly prohibited that community or when participation is inherently incompatible with the assignment. Empty exclusion arrays are correct when no such negative constraint exists.",
       "Never forbid or exclude a broad ancestor, descendant, adjacent, or legitimately co-occurring community merely because a narrower job family was selected. Check every exclusion against all requiredCommunities and optionalCommunities before returning JSON.",
-      "Hard requirements mean absence makes the assignment impossible and the Hub catalog must prove eligibility; importance alone is not a hard gate. Prefer a broad required community plus optional skills when legacy declarations may be sparse. requiredRoles must default to []; there is no optionalRoles field, so express desired role fit through title, task, optionalCommunities, and optionalSkills unless the exact role declaration is truly execution-impossible to omit.",
-      "A requiredToolCapabilities entry means the selected worker itself must invoke that exact host tool. Designing a database, writing tests, or discussing a tool does not by itself require tool:database, tool:shell, or any other tool declaration.",
-      "consumes and produces require the selected Hub candidate profile itself to declare those exact artifacts. Ordinary workflow dependencies and handoffs belong in task and edges, not these hard fields.",
+      "Hard requirements mean absence makes the assignment impossible and the Hub catalog must prove eligibility; importance alone is not a hard gate. Prefer a broad required community plus optional skills when legacy declarations may be sparse. Do not author requiredRoles; express desired role fit through title, task, optionalCommunities, and optionalSkills.",
+      "Do not author requiredToolCapabilities, requiredAuthorities, forbiddenAuthorities, consumes, produces, or modalities: tools, authorities, and modalities attach to the executing runtime, not the agent card, and card-declaration gates on those fields only exclude real candidates. Ordinary workflow dependencies and handoffs belong in task and edges.",
       "Before returning JSON, self-check that every explicitly named specialized domain responsibility is independently represented, every primary domain responsibility has an accountable slot, every exclusion is explicit or inherently incompatible and does not conflict with job-family lineage, requiredRoles is empty unless strictly indispensable, and every other hard field passes the execution-impossible test.",
       "Return exactly one direct WorkOrder JSON object. Do not choose agents yet. Do not use ratings, popularity, invocation history, or revenue.",
-      "You must explicitly author every required schema field. The host will never fill or default a missing hard field.",
+      "Explicitly author every structural field (slotId, title, task, cardinality, criticality, allowedEntityKinds, edges, forbiddenCommunities, selectionPolicy). A list-valued slot field you leave out is the empty constraint; the host normalizes absent to [].",
       "Never copy secrets, local file contents, account identifiers, or private memory into taskBrief; summarize them as local protected inputs and set redacted=true.",
       `ontologyVersion must be exactly ${WORKFORCE_ONTOLOGY_VERSION}.`,
-      WORKFORCE_ONTOLOGY_MENU,
+      WORKFORCE_ONTOLOGY_GUIDE,
       searchSchemaRequirements,
     ].join("\n"),
     searchUser: task,
@@ -1906,12 +1923,12 @@ function buildPrompts(task, identity) {
       "Return a complete replacement WorkOrder authored by you. Preserve workOrderId and the redacted taskBrief exactly. Preserve every genuinely essential responsibility; add or separate an omitted accountable domain job family when the task requires it.",
       "Any specialized domain explicitly present in the task with distinct failure or accountability semantics must remain or become its own accountable domain slot. Examples include payments, insurance, legal, finance, travel, and regulated science or operations. Never collapse one into generic backend, software, database, or implementation work.",
       "Reconsider only hard eligibility gates exposed by the gap codes. gap:excluded:missing-required-skill means reassess requiredSkills and move desired expertise to optionalSkills/task unless exact profile proof is execution-essential. gap:excluded:missing-required-tool means remove or revise requiredToolCapabilities unless the worker itself must invoke that exact host tool. gap:excluded:missing-consumed-artifact and gap:excluded:missing-produced-artifact mean move normal workflow inputs/outputs to task or edges unless the candidate profile itself must declare that exact artifact. gap:excluded:entity-kind-mismatch means reconsider allowedEntityKinds and permit executable agent or team when it can own the accountability; never select group. gap:selection-requested-content-expansion means revisit the responsibility and semantic job-family description without reading candidate identities or content.",
-      "requiredRoles must default to []; because optionalRoles does not exist, move desired role fit to title, task, optionalCommunities, or optionalSkills unless absence of the exact declared role truly makes execution impossible. A required tool means the worker must invoke that exact host tool, not merely reason about the underlying system. consumes and produces are exact candidate-profile declaration gates; ordinary handoffs belong in task and edges.",
+      "Do not author requiredRoles, requiredToolCapabilities, requiredAuthorities, forbiddenAuthorities, consumes, produces, or modalities; move desired fit to title, task, optionalCommunities, or optionalSkills — ordinary handoffs belong in task and edges.",
       "Preserve community prohibitions explicitly stated in the redacted taskBrief. You may correct exclusions inferred by the prior job analysis when they conflict with required/optional job-family lineage or when coverage gap codes show forbidden-community exclusion. Never turn forbiddenCommunities or excludedCommunities into an exhaustive list of unused families, and never forbid a broad, adjacent, or legitimately co-occurring community merely to sharpen a slot.",
       "Before returning JSON, self-check that each explicitly named specialized domain responsibility has an independent accountable slot and that every hard gate still satisfies the execution-impossible or exact-profile-declaration test.",
       "The host will validate your replacement exactly and will not add slots, defaults, constraints, candidates, or substitutions. At most two total semantic WorkOrder refinements are allowed.",
       `ontologyVersion must remain exactly ${WORKFORCE_ONTOLOGY_VERSION}.`,
-      WORKFORCE_ONTOLOGY_MENU,
+      WORKFORCE_ONTOLOGY_GUIDE,
       searchSchemaRequirements,
     ].join("\n"),
     selectionSystem: [

package/engine/cloud-assets/commands.cjs

@@ -10,12 +10,161 @@
  *    명시적 --visibility marketplace 로만 publish가 된다.
  * 오류는 throw → 명령 파일이 ctx.err + return 1 로 처리한다 (process.exit 금지).
  */
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const readline = require("node:readline/promises");
 const cloudRuntime = require("../agentlas-cloud-runtime.cjs");
 const { installHubAgent } = require("../hub/install.cjs");
 const { callHubTool, HubError } = require("../cloud/hub-client.cjs");
 const { packageCloudAgent } = require("./package.cjs");
 const { deleteCloudAgent } = require("./cas.cjs");
 const { listOwnedCloudAgents, restoreOwnedCloudAgent } = require("./restore.cjs");
+const workforceDeps = require("../workforce/deps.cjs");
+const workforceCapture = require("../workforce/capture.cjs");
+
+const PURPOSE_QUESTION = "What concrete work should this agent complete, and what should the finished result look like?";
+
+function purposeRepairNeeded(result) {
+  const ids = new Set((result?.review?.findings || []).map((finding) => finding.id));
+  return ids.has("routing-card-required") ||
+    (result?.review?.findings || []).some((finding) =>
+      finding.id === "routing-card-invalid" && /summary|capabilities|name|id|workforce/i.test(finding.message || ""));
+}
+
+async function askPurpose(ctx, flags) {
+  if (typeof flags.purpose === "string" && flags.purpose.trim()) return flags.purpose.trim();
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return "";
+  const prompt = ctx.lang === "ko"
+    ? "이 에이전트가 실제로 끝내야 할 일과, 완료됐을 때 나와야 할 결과를 평소 말하듯 적어주세요: "
+    : `${PURPOSE_QUESTION} `;
+  const terminal = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return String(await terminal.question(prompt)).trim();
+  } finally {
+    terminal.close();
+  }
+}
+
+function parsePurposeProjection(raw) {
+  const text = String(raw || "").trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
+  const value = JSON.parse(text);
+  const ids = (input, prefix, min = 1) => {
+    if (!Array.isArray(input)) throw new Error(`${prefix} must be an array`);
+    const pattern = prefix === "capability"
+      ? /^[a-z][a-z0-9]*(_[a-z0-9]+)+$/
+      : new RegExp(`^${prefix}:[a-z0-9][a-z0-9-]*$`);
+    const output = [...new Set(input.map((item) => String(item).trim()).filter((item) => pattern.test(item)))];
+    if (output.length < min) throw new Error(`${prefix} is incomplete`);
+    return output;
+  };
+  const requiredText = (key) => {
+    const output = typeof value[key] === "string" ? value[key].trim() : "";
+    if (!output) throw new Error(`${key} is missing`);
+    return output;
+  };
+  return {
+    titleEn: requiredText("titleEn"),
+    titleKo: requiredText("titleKo"),
+    summary: requiredText("summary"),
+    descriptionKo: requiredText("descriptionKo"),
+    capabilities: ids(value.capabilities, "capability", 2),
+    roles: ids(value.roles, "role"),
+    communities: ids(value.communities, "community"),
+    skills: ids(value.skills, "skill", 2),
+    knowledge: ids(value.knowledge, "knowledge"),
+  };
+}
+
+async function projectPurposeWithConnectedModel(ctx, answer, fallbackName) {
+  const runtime = workforceDeps.resolveWorkforceRuntime(ctx.db()).roleRuntimes.orchestrator;
+  const system = [
+    "Convert an ordinary-language agent purpose into one English internal routing resume.",
+    "The answer may be in any language. Preserve meaning; do not add tools, runtimes, languages, modalities, permissions, authorities, or forbidden authorities.",
+    "Return JSON only.",
+  ].join(" ");
+  const prompt = [
+    `Working name: ${fallbackName}`,
+    `User explanation: ${answer}`,
+    "",
+    'Return {"titleEn":"","titleKo":"","summary":"","descriptionKo":"","capabilities":[],"roles":[],"communities":[],"skills":[],"knowledge":[]}.',
+    "summary must be a concrete English description of work and finished result.",
+    "capabilities are 2-8 English snake_case verb-object phrases.",
+    "roles, communities, skills, knowledge are faithful open-world English IDs with role:, community:, skill:, knowledge: prefixes.",
+    "titleKo and descriptionKo are display translations only; every routing field remains English.",
+  ].join("\n");
+  let raw;
+  if (runtime.mode === "api") {
+    raw = await workforceCapture.runApi(runtime.backend, runtime.model, system, prompt, {});
+  } else {
+    if (runtime.kind === "gemini") {
+      throw new Error("The connected Gemini CLI cannot run this no-tool repair safely yet. Choose Codex/Claude or a BYOK model and retry.");
+    }
+    const env = await workforceCapture.buildChildEnv(ctx.db(), { cwd: process.cwd(), projectPath: process.cwd() });
+    raw = await workforceCapture.captureRuntime(runtime.kind, system, prompt, {
+      cwd: workforceCapture.runCwd(),
+      env,
+      permission: "read",
+      authorityMode: "no-authority",
+      model: runtime.model,
+      effort: runtime.effort,
+      timeoutConfig: { connectMs: 30_000, idleMs: 45_000, totalMs: 90_000 },
+      outputLimitBytes: 256 * 1024,
+    });
+  }
+  return parsePurposeProjection(raw);
+}
+
+function writePurposeRepairCopy(root, projection) {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "agentlas-purpose-repair-"));
+  fs.cpSync(path.resolve(root), tempRoot, { recursive: true, dereference: false });
+  const metadataDir = path.join(tempRoot, ".agentlas");
+  fs.mkdirSync(metadataDir, { recursive: true });
+  const routingPath = path.join(metadataDir, "routing-card.json");
+  let routing = {};
+  try { routing = JSON.parse(fs.readFileSync(routingPath, "utf8")); } catch { /* construct it */ }
+  const id = String(routing.id || path.basename(root))
+    .normalize("NFKC").toLowerCase().replace(/[^a-z0-9._/-]+/g, "-").replace(/^-|-$/g, "") || "agent";
+  const card = {
+    ...routing,
+    schemaVersion: "routing-card/2.0",
+    id,
+    type: routing.type === "team" || routing.type === "plugin" ? routing.type : "agent",
+    name: projection.titleEn,
+    summary: projection.summary.slice(0, 240),
+    capabilities: projection.capabilities,
+    routing_status: "routing_ready",
+    workforce: {
+      ...(routing.workforce && typeof routing.workforce === "object" && !Array.isArray(routing.workforce)
+        ? routing.workforce
+        : {}),
+      roles: projection.roles,
+      communities: projection.communities,
+      skills: projection.skills,
+      knowledge: projection.knowledge,
+      languages: [],
+      modalities: [],
+    },
+  };
+  fs.writeFileSync(routingPath, `${JSON.stringify(card, null, 2)}\n`, "utf8");
+  const agentCardPath = path.join(metadataDir, "agent-card.json");
+  let agentCard = {};
+  try { agentCard = JSON.parse(fs.readFileSync(agentCardPath, "utf8")); } catch { /* construct it */ }
+  agentCard = {
+    ...agentCard,
+    name: agentCard.name || projection.titleEn,
+    summary: projection.summary,
+    localized: {
+      ...(agentCard.localized && typeof agentCard.localized === "object" ? agentCard.localized : {}),
+      titleEn: projection.titleEn,
+      titleKo: projection.titleKo,
+      descriptionEn: projection.summary,
+      descriptionKo: projection.descriptionKo,
+    },
+  };
+  fs.writeFileSync(agentCardPath, `${JSON.stringify(agentCard, null, 2)}\n`, "utf8");
+  return tempRoot;
+}
 
 function parseCloudFlags(args) {
   const flags = { _: [] };
@@ -102,6 +251,7 @@ const CLOUD_HELP = [
   "                                      save owner-private in Agent Cloud (default upload)",
   "  publish <path> [--dry-run] [--slug name]",
   "                                      explicitly publish to the public Agentlas Hub",
+  "  --purpose \"ordinary explanation\"     repair a missing purpose through your connected model",
   "  package <path> [--json] [--visibility private-link|marketplace]",
   "  --overwrite                         서버에 더 새 버전이 있어도 지금 폴더 내용으로 덮어쓰기",
   "                                      package only; defaults to private-save checks",
@@ -238,13 +388,30 @@ async function runCloud(ctx, args) {
   if (!root) { ctx.err(`usage: agentlas cloud ${sub} <path>`); return 1; }
   const visibility = cloudVisibilityForAction(sub, flags);
   const dryRun = sub === "package" || Boolean(flags["dry-run"]);
-  const result = await packageCloudAgent(ctx.db(), root, {
+  const packageOptions = {
     slug: typeof flags.slug === "string" ? flags.slug : undefined,
     visibility,
     llmReview: Boolean(flags["llm-review"]),
     overwriteRemote: Boolean(flags.overwrite),
     dryRun,
-  });
+  };
+  let result = await packageCloudAgent(ctx.db(), root, packageOptions);
+  if (sub === "publish" && result.status === "blocked" && purposeRepairNeeded(result) && !flags.json) {
+    const answer = await askPurpose(ctx, flags);
+    if (answer) {
+      const projection = await projectPurposeWithConnectedModel(ctx, answer, path.basename(path.resolve(root)));
+      const repairedRoot = writePurposeRepairCopy(root, projection);
+      try {
+        result = await packageCloudAgent(ctx.db(), repairedRoot, packageOptions);
+      } finally {
+        fs.rmSync(repairedRoot, { recursive: true, force: true });
+      }
+    } else {
+      ctx.err(ctx.lang === "ko"
+        ? `업로드를 완성하려면 답이 필요합니다. 다시 실행할 때 --purpose "평소 말로 설명"을 붙이세요.`
+        : `This upload needs one answer. Retry with --purpose "your ordinary explanation".`);
+    }
+  }
   if (flags.json) {
     ctx.out(JSON.stringify(result, null, 2));
     return (sub === "save" || sub === "publish") && result.status === "blocked" ? 1 : 0;
@@ -269,6 +436,8 @@ module.exports = {
   cloudVisibilityFlag,
   cloudVisibilityForAction,
   cloudActionForTopLevelUpload,
+  purposeRepairNeeded,
+  parsePurposeProjection,
   printCloudPackageResult,
   runCloud,
   runUpload,

package/engine/cloud-assets/package.cjs

@@ -577,6 +577,7 @@ function cloudRoutingCardProblem(card) {
   if (card.type !== "agent" && card.type !== "team" && card.type !== "plugin") return "type must be agent, team, or plugin";
   if (typeof card.name !== "string" || !card.name.trim()) return "name must be a non-empty string";
   if (typeof card.summary !== "string" || !card.summary.trim()) return "summary must be a non-empty string";
+  if (card.summary.length > 240) return "summary must be at most 240 characters";
   if (!Array.isArray(card.capabilities) || card.capabilities.length === 0) return "capabilities must be a non-empty array";
   for (const capability of card.capabilities) {
     if (typeof capability !== "string" || !CLOUD_ROUTING_CARD_CAPABILITY_RE.test(capability)) {
@@ -586,6 +587,33 @@ function cloudRoutingCardProblem(card) {
   if (typeof card.routing_status !== "string" || !CLOUD_ROUTING_CARD_STATUSES.has(card.routing_status)) {
     return "routing_status must be draft, searchable, candidate, routing_ready, or trusted";
   }
+  const workforce = card.workforce;
+  if (!workforce || typeof workforce !== "object" || Array.isArray(workforce)) {
+    return "workforce must be a complete semantic resume";
+  }
+  const semanticLists = [
+    ["communities", /^community:[a-z0-9][a-z0-9-]*$/, 1, 5],
+    ["roles", /^role:[a-z0-9][a-z0-9-]*$/, 0, 4],
+    ["skills", /^skill:[a-z0-9][a-z0-9-]*$/, 1, 12],
+    ["knowledge", /^knowledge:[a-z0-9][a-z0-9-]*$/, 0, 256],
+  ];
+  for (const [field, pattern, minimum, maximum] of semanticLists) {
+    const values = workforce[field];
+    if (!Array.isArray(values) || values.length < minimum || values.length > maximum) {
+      return `workforce.${field} must contain ${minimum}-${maximum} English semantic IDs`;
+    }
+    if (new Set(values).size !== values.length ||
+        values.some((value) => typeof value !== "string" || !pattern.test(value))) {
+      return `workforce.${field} contains an invalid or duplicate semantic ID`;
+    }
+  }
+  for (const field of ["languages", "modalities"]) {
+    const values = workforce[field];
+    if (!Array.isArray(values) || new Set(values).size !== values.length ||
+        values.some((value) => typeof value !== "string")) {
+      return `workforce.${field} must be a unique string array`;
+    }
+  }
   return null;
 }
 

package/engine/commands/plugin.cjs

@@ -12,6 +12,7 @@ const {
   installPluginMcpRows,
   listHubPlugins,
 } = require("../hub/plugins.cjs");
+const { terminalProjectCandidateCli, initializedAgentlasProjectPathCli } = require("../project/state.cjs");
 
 async function pluginAdd(ctx, slug) {
   if (!slug) {
@@ -90,12 +91,90 @@ async function pluginList(ctx) {
   return 0;
 }
 
+async function pluginListWithProject(ctx, projectPath) {
+  const root = terminalProjectCandidateCli(projectPath);
+  if (!root) {
+    ctx.err(`project path is invalid or not safe: ${projectPath}`);
+    return 1;
+  }
+  if (!initializedAgentlasProjectPathCli(root)) {
+    ctx.err("project is not initialized for plugin listing. Run `agentlas project init` in that folder first.");
+    return 1;
+  }
+  ctx.out("Scope: global Hub plugin catalog (project compatibility and local installation state are not evaluated).");
+  return pluginList(ctx);
+}
+
+function parsePluginListFlags(args) {
+  const flags = {
+    global: false,
+    project: null,
+    errors: [],
+    positionals: [],
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--global") {
+      flags.global = true;
+      continue;
+    }
+    if (arg === "--project") {
+      const next = args[i + 1];
+      if (!next || next.startsWith("-")) {
+        flags.errors.push("usage: agentlas plugin list --project <path>");
+        return flags;
+      }
+      flags.project = next;
+      i += 1;
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      flags.errors.push("usage: agentlas plugin list [--global | --project <path>]");
+      return flags;
+    }
+    if (arg.startsWith("--")) {
+      flags.errors.push(`unknown flag: ${arg}`);
+      return flags;
+    }
+    flags.positionals.push(arg);
+  }
+  if (flags.project && flags.global) {
+    flags.errors.push("cannot use --project and --global together");
+  }
+  if (flags.positionals.length > 0) {
+    flags.errors.push("usage: agentlas plugin list [--global | --project <path>]");
+  }
+  return flags;
+}
+
+async function runPluginList(ctx, args) {
+  const flags = parsePluginListFlags(args);
+  if (flags.errors.length) {
+    ctx.err(flags.errors[0]);
+    return 1;
+  }
+  if (flags.project) return pluginListWithProject(ctx, flags.project);
+  return pluginList(ctx);
+}
+
 function run(ctx, args) {
   const action = args[0];
-  if (action === "add") return pluginAdd(ctx, args[1]);
-  if (action === "list" || !action) return pluginList(ctx);
+  if (action === "add") {
+    if (args.length !== 2) {
+      ctx.err("usage: agentlas plugin add <slug>   (run agentlas plugin list first)");
+      return 1;
+    }
+    return pluginAdd(ctx, args[1]);
+  }
+  if (action === "list" || !action) {
+    const rest = action === "list" ? args.slice(1) : [];
+    return runPluginList(ctx, rest);
+  }
   ctx.err("usage: agentlas plugin add <slug> | agentlas plugin list");
   return 1;
 }
 
-module.exports = { run };
+module.exports = {
+  run,
+  parsePluginListFlags,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentlas",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "Agentlas agent terminal — chat with your installed AI agents and teams from the terminal, Claude Code style. Standalone: no desktop app required.",
   "bin": {
     "agentlas": "bin/agentlas.cjs"