@piagent/platform 1.1.5 → 1.1.7

package/packages/piagent-core/capabilities/project-profile.js

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import path from "node:path";
+
+// A project profile can either state its whole policy or name the adapter it
+// takes that policy from.
+//
+// Stating the whole policy freezes it. The adapters ship with the platform and
+// are corrected by it, but a project that copied one at onboarding time keeps
+// the copy forever, so a global update leaves every existing project on the old
+// rules. `extends` makes the policy a reference instead: the project keeps the
+// parts that are about the project, and the installed platform supplies the
+// rest.
+//
+// Profiles written before this existed carry no `extends` and keep working
+// exactly as they did, self-contained.
+
+const ADAPTER_NAME = /^[a-z0-9][a-z0-9-]{0,63}$/;
+
+export class ProjectProfileError extends Error {}
+
+export function adapterProfileFile(platformRoot, name) {
+  if (typeof name !== "string") return undefined;
+  const trimmed = name.trim();
+  // The name indexes a directory inside the installed platform, so it is
+  // restricted to a plain slug rather than sanitised after the fact.
+  if (!ADAPTER_NAME.test(trimmed)) return undefined;
+  const candidate = path.join(platformRoot, "adapters", trimmed, "profile.json");
+  return fs.existsSync(candidate) ? candidate : undefined;
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Resolve a stored project profile document against the installed adapters.
+ * Returns the document to enforce, plus the adapter it came from when one was
+ * named. Any key the project states replaces the adapter's key whole — there is
+ * no per-entry merging of lists, because a half-merged protectedPaths is harder
+ * to reason about than a stated one.
+ */
+export function resolveProjectProfileDocument(platformRoot, stored) {
+  if (!stored || typeof stored !== "object" || Array.isArray(stored)) {
+    return { profile: stored, base: undefined };
+  }
+  if (stored.extends === undefined) return { profile: stored, base: undefined };
+
+  const file = adapterProfileFile(platformRoot, stored.extends);
+  if (!file) {
+    throw new ProjectProfileError(
+      `project profile extends "${String(stored.extends)}", which is not an adapter in the installed platform`
+    );
+  }
+  const adapter = readJson(file);
+  if (!adapter) throw new ProjectProfileError(`adapter profile is unreadable: ${file}`);
+
+  const { extends: base, ...overrides } = stored;
+  return { profile: { ...adapter, ...overrides }, base };
+}
+
+export function readProjectProfileDocument(platformRoot, profilePath) {
+  const stored = readJson(profilePath);
+  if (stored === undefined) return { stored: undefined, profile: undefined, base: undefined };
+  const { profile, base } = resolveProjectProfileDocument(platformRoot, stored);
+  return { stored, profile, base };
+}
+
+/**
+ * The document a project stores when it takes its policy from an adapter: what
+ * identifies this project, and nothing the platform already knows.
+ */
+export function buildExtendingProfile(base, projectId, displayName) {
+  return {
+    schemaVersion: 1,
+    extends: base,
+    projectId,
+    displayName
+  };
+}

package/packages/piagent-core/extensions/piagent-guard.ts

@@ -39,9 +39,12 @@ import {
   redactForStorage,
   redactSensitiveText
 } from "./redaction-core.js";
+import { detectProfileName } from "./project-shape.js";
+import { buildExtendingProfile, resolveProjectProfileDocument } from "../capabilities/project-profile.js";
 import {
   resolveCapabilityProfileDocument,
   verifyCapabilityLock,
+  writeJsonAtomic,
   writeProfileLockAtomic
 } from "../capabilities/capability-core.js";
 import { resolveCapabilitySourceRoots } from "../capabilities/capability-sources.js";
@@ -416,6 +419,10 @@ const DEFAULT_POLICY: BasePolicy = {
   orchestrationPolicy: DEFAULT_ORCHESTRATION_POLICY
 };
 
+// Which platform supplies the adapters is fixed by where this file is installed,
+// so it is resolved once here rather than threaded through every profile load.
+const PLATFORM_ROOT = findPlatformRoot(path.dirname(fileURLToPath(import.meta.url)));
+
 function loadPolicy(extensionDir: string): BasePolicy {
   const root = findPackageRoot(extensionDir);
   return readJsonFile<BasePolicy>(path.join(root, "policies", "base-policy.json")) ?? DEFAULT_POLICY;
@@ -432,17 +439,38 @@ function fallbackProfile(cwd: string, mode = "unprofiled"): ProjectProfile {
   };
 }
 
+// A profile that names an adapter this platform does not have cannot be
+// enforced, and the unprofiled shape carries no readOnlyPaths — falling back to
+// it would quietly hand write access to whatever the profile was protecting. The
+// session stays readable and says why instead.
+function unresolvedProfile(cwd: string, reason: string): ProjectProfile {
+  return {
+    ...fallbackProfile(cwd, "unresolved-profile-base"),
+    permissionProfile: "read-only",
+    unresolvedReason: reason
+  } as ProjectProfile;
+}
+
+function resolveStoredProfile(stored: ProjectProfile | undefined, cwd: string, missingMode: string): ProjectProfile {
+  if (!stored) return fallbackProfile(cwd, missingMode);
+  try {
+    return resolveProjectProfileDocument(PLATFORM_ROOT, stored).profile as ProjectProfile;
+  } catch (error) {
+    return unresolvedProfile(cwd, error instanceof Error ? error.message : String(error));
+  }
+}
+
 function loadProfile(cwd: string, projectTrusted = false): ProjectProfile {
   const explicit = process.env.PIAGENT_PROFILE;
   if (explicit && explicit.trim().length > 0) {
-    return readJsonFile<ProjectProfile>(explicit) ?? fallbackProfile(cwd, "explicit-profile-unreadable");
+    return resolveStoredProfile(readJsonFile<ProjectProfile>(explicit), cwd, "explicit-profile-unreadable");
   }
 
   if (!projectTrusted) {
     return fallbackProfile(cwd, "unprofiled-global-package");
   }
 
-  return readJsonFile<ProjectProfile>(path.join(cwd, ".pi", "piagent-profile.json")) ?? fallbackProfile(cwd, projectTrusted ? "unprofiled" : "unprofiled-global-package");
+  return resolveStoredProfile(readJsonFile<ProjectProfile>(path.join(cwd, ".pi", "piagent-profile.json")), cwd, "unprofiled");
 }
 
 function loadProfileFromContext(ctx: ExtensionContext): ProjectProfile {
@@ -529,6 +557,7 @@ function capabilitySourceRoots(
 type ProjectCapabilityState = {
   ok: boolean;
   reason?: string;
+  repinned?: string;
   filesystemRead?: string[];
   filesystemWrite?: string[];
 };
@@ -538,8 +567,18 @@ function verifyProjectCapabilityState(extensionDir: string, cwd: string, project
   if (!projectTrusted) return { ok: true };
   const profilePath = projectProfilePath(cwd);
   if (!fs.existsSync(profilePath)) return { ok: true };
-  const profile = readJsonFile<ProjectProfile>(profilePath);
-  if (!profile || !Array.isArray(profile.capabilityPacks)) return { ok: true };
+  // Which packs a project selects can come from the adapter it extends, so the
+  // question has to be asked of the resolved document. Asking the stored one
+  // would skip the lock entirely for every project that references an adapter.
+  const stored = readJsonFile<ProjectProfile>(profilePath);
+  if (!stored) return { ok: true };
+  let profile: ProjectProfile;
+  try {
+    profile = resolveProjectProfileDocument(PLATFORM_ROOT, stored).profile as ProjectProfile;
+  } catch (error) {
+    return { ok: false, reason: error instanceof Error ? error.message : String(error) };
+  }
+  if (!Array.isArray(profile.capabilityPacks)) return { ok: true };
   const lockPath = path.join(cwd, ".pi", "piagent-profile.lock.json");
   if (!fs.existsSync(lockPath)) return { ok: false, reason: "Capability lock is missing. Reapply the project profile." };
   const lock = readJsonFile<Record<string, unknown>>(lockPath);
@@ -549,13 +588,30 @@ function verifyProjectCapabilityState(extensionDir: string, cwd: string, project
       packageSource: projectPackageSource(cwd),
       extraRoots: capabilitySourceRoots(cwd, profile)
     });
-    return verification.ok
-      ? {
-          ok: true,
-          filesystemRead: verification.expected.permissions.filesystemRead,
-          filesystemWrite: verification.expected.permissions.filesystemWrite
-        }
-      : { ok: false, reason: "Capability lock does not match the active profile, package source, or installed platform." };
+    if (verification.status === "blocked") {
+      return {
+        ok: false,
+        reason: `Capability lock does not match what this project agreed to: ${verification.reasons.join("; ")}. Reapply the project profile.`
+      };
+    }
+    const granted = {
+      filesystemRead: verification.expected.permissions.filesystemRead,
+      filesystemWrite: verification.expected.permissions.filesystemWrite
+    };
+    if (verification.status !== "repin") return { ok: true, ...granted };
+
+    // The grant is unchanged and only the platform build moved. Record the new
+    // build instead of stopping the session, which is what turned every release
+    // into a chore in every project.
+    try {
+      writeJsonAtomic(lockPath, verification.expected);
+    } catch (error) {
+      return {
+        ok: false,
+        reason: `Capability lock is behind the installed platform and could not be rewritten: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+    return { ok: true, repinned: verification.reasons.join("; "), ...granted };
   } catch (error) {
     return { ok: false, reason: `Capability validation failed: ${error instanceof Error ? error.message : String(error)}` };
   }
@@ -2636,75 +2692,6 @@ function readAdapterProfiles(extensionDir: string): Array<{ name: string; profil
     .sort((a, b) => a.name.localeCompare(b.name));
 }
 
-function packageHasAny(cwd: string, pattern: RegExp): boolean {
-  try {
-    return pattern.test(fs.readFileSync(path.join(cwd, "package.json"), "utf8"));
-  } catch {
-    return false;
-  }
-}
-
-function detectProfileName(cwd: string, intent?: string): { name: string; reason: string } {
-  const normalizedIntent = intent?.trim().toLowerCase();
-  if (normalizedIntent === "be-readonly-fe") return { name: "be-readonly-fe", reason: "User intent says backend should be read-only while frontend is the write target." };
-  if (normalizedIntent === "frontend-only") return { name: "web-frontend", reason: "User intent says frontend-only." };
-  if (normalizedIntent === "backend-only") return { name: "backend-api", reason: "User intent says backend-only." };
-  if (normalizedIntent === "docs") return { name: "docs", reason: "User intent says docs/docs-only." };
-
-  const hasPackage = fs.existsSync(path.join(cwd, "package.json"));
-  let frontend = false;
-  let backend = false;
-  let data = false;
-  let mobile = false;
-  let infra = false;
-  let docs = false;
-
-  if (fs.existsSync(path.join(cwd, "pubspec.yaml")) || (fs.existsSync(path.join(cwd, "android")) && fs.existsSync(path.join(cwd, "ios")))) mobile = true;
-  if (fs.existsSync(path.join(cwd, "dbt_project.yml")) || fs.existsSync(path.join(cwd, "dvc.yaml")) || fs.existsSync(path.join(cwd, "notebooks")) || fs.existsSync(path.join(cwd, "data"))) data = true;
-  if (fs.existsSync(path.join(cwd, "Dockerfile")) || fs.existsSync(path.join(cwd, "docker-compose.yml")) || fs.existsSync(path.join(cwd, "compose.yml")) || fs.existsSync(path.join(cwd, "compose.yaml")) || fs.existsSync(path.join(cwd, "terraform")) || fs.existsSync(path.join(cwd, "infra")) || fs.existsSync(path.join(cwd, "k8s")) || fs.existsSync(path.join(cwd, "helm"))) infra = true;
-  if (fs.existsSync(path.join(cwd, "docs")) || fs.existsSync(path.join(cwd, "mkdocs.yml")) || fs.existsSync(path.join(cwd, "mint.json")) || fs.existsSync(path.join(cwd, "docusaurus.config.js"))) docs = true;
-
-  if (hasPackage) {
-    if (fs.existsSync(path.join(cwd, "frontend")) || fs.existsSync(path.join(cwd, "apps/web")) || fs.existsSync(path.join(cwd, "apps/frontend"))) frontend = true;
-    if (fs.existsSync(path.join(cwd, "backend")) || fs.existsSync(path.join(cwd, "apps/api")) || fs.existsSync(path.join(cwd, "apps/server"))) backend = true;
-    if (packageHasAny(cwd, /"(next|react|vite|vue|svelte|astro|@angular\/core|remix)"/i)
-      || fs.existsSync(path.join(cwd, "next.config.js"))
-      || fs.existsSync(path.join(cwd, "next.config.mjs"))
-      || fs.existsSync(path.join(cwd, "next.config.ts"))
-      || fs.existsSync(path.join(cwd, "vite.config.js"))
-      || fs.existsSync(path.join(cwd, "vite.config.ts"))
-      || fs.existsSync(path.join(cwd, "src/app"))
-      || fs.existsSync(path.join(cwd, "pages"))
-      || fs.existsSync(path.join(cwd, "public"))) frontend = true;
-    if (packageHasAny(cwd, /"(@nestjs|express|fastify|hono|koa|apollo-server|graphql-yoga|prisma|typeorm|sequelize|drizzle-orm)"/i)
-      || fs.existsSync(path.join(cwd, "nest-cli.json"))
-      || fs.existsSync(path.join(cwd, "prisma"))
-      || fs.existsSync(path.join(cwd, "src/server"))
-      || fs.existsSync(path.join(cwd, "src/api"))) backend = true;
-  }
-
-  if (fs.existsSync(path.join(cwd, "pom.xml")) || fs.existsSync(path.join(cwd, "build.gradle")) || fs.existsSync(path.join(cwd, "build.gradle.kts")) || fs.existsSync(path.join(cwd, "src/main/java")) || fs.existsSync(path.join(cwd, "src/main/kotlin"))) backend = true;
-
-  if (fs.existsSync(path.join(cwd, "pyproject.toml"))) {
-    try {
-      if (/(fastapi|flask|django|litestar|starlite)/i.test(fs.readFileSync(path.join(cwd, "pyproject.toml"), "utf8"))) backend = true;
-    } catch {
-      // ignore unreadable pyproject for recommendation
-    }
-  }
-
-  if (mobile) return { name: "mobile", reason: "Mobile markers found." };
-  if (frontend && backend) return { name: "fullstack", reason: "Frontend and backend markers both found. Pick be-readonly-fe instead if backend must be read-only." };
-  if (frontend) return { name: "web-frontend", reason: "Frontend framework markers found." };
-  if (backend) return { name: "backend-api", reason: "Backend/API markers found." };
-  if (data) return { name: "data", reason: "Data/ETL markers found." };
-  if (fs.existsSync(path.join(cwd, "pyproject.toml"))) return { name: "python", reason: "Python pyproject.toml found." };
-  if (hasPackage && fs.existsSync(path.join(cwd, "tsconfig.json"))) return { name: "node-typescript", reason: "Node TypeScript markers found." };
-  if (infra) return { name: "devops", reason: "Infrastructure markers found." };
-  if (docs) return { name: "docs", reason: "Documentation markers found." };
-  return { name: "generic", reason: "No stronger project markers found." };
-}
-
 function profileDescription(name: string): string {
   const descriptions: Record<string, string> = {
     generic: "Safe baseline for unknown repos.",
@@ -2922,12 +2909,18 @@ function buildTechStackManifest(profileName: string, selectedOptions: TechOption
   };
 }
 
+// `profile` is the document the project stores. When it names an adapter, the
+// lock is resolved against that adapter but still records the stored document,
+// so a later platform correction is not a lock the project has to re-agree to.
 function writeProfileDocumentWithLock(extensionDir: string, cwd: string, profile: ProjectProfile): ProjectProfile {
   const target = projectProfilePath(cwd);
-  const capabilityLock = resolveCapabilityProfileDocument(findPlatformRoot(extensionDir), profile, {
+  const platformRoot = findPlatformRoot(extensionDir);
+  const resolved = resolveProjectProfileDocument(platformRoot, profile).profile as ProjectProfile;
+  const capabilityLock = resolveCapabilityProfileDocument(platformRoot, resolved, {
     profileFile: "piagent-profile.json",
+    storedProfile: profile,
     packageSource: projectPackageSource(cwd),
-    extraRoots: capabilitySourceRoots(cwd, profile)
+    extraRoots: capabilitySourceRoots(cwd, resolved)
   });
   fs.mkdirSync(path.dirname(target), { recursive: true });
   writeProfileLockAtomic(target, profile, path.join(cwd, ".pi", "piagent-profile.lock.json"), capabilityLock);
@@ -2977,7 +2970,7 @@ function writeTechStackSelection(
   };
   writeProfileDocumentWithLock(extensionDir, cwd, profile);
   ensureProjectContextPlaceholder(cwd);
-  return { profile, manifest };
+  return { profile: resolveProjectProfileDocument(findPlatformRoot(extensionDir), profile).profile as ProjectProfile, manifest };
 }
 
 function normalizeTechSelections(cwd: string, profileName: string, selections: Record<string, unknown> = {}, fillRecommended = true): {
@@ -3101,20 +3094,24 @@ function buildProfileFromAdapter(extensionDir: string, cwd: string, profileName:
   const profile = readJsonFile<ProjectProfile>(source);
   if (!profile) throw new Error(`Profile unreadable: ${profileName}`);
   const projectName = path.basename(cwd);
-  return {
-    ...profile,
-    projectId: projectId ? slugify(projectId) : slugify(projectName),
-    displayName: displayName?.trim() || titleize(projectName)
-  };
+  // The project records which adapter it follows, not a copy of that adapter's
+  // rules. A copy stops receiving corrections the moment it is written.
+  return buildExtendingProfile(
+    profileName,
+    projectId ? slugify(projectId) : slugify(projectName),
+    displayName?.trim() || titleize(projectName)
+  ) as ProjectProfile;
 }
 
 function writeProfileFromAdapter(extensionDir: string, cwd: string, profileName: string, overwrite = false, projectId?: string, displayName?: string): ProjectProfile {
   const target = projectProfilePath(cwd);
   if (fs.existsSync(target) && !overwrite) throw new Error(".pi/piagent-profile.json already exists. Pass overwrite=true to replace it.");
-  const personalized = buildProfileFromAdapter(extensionDir, cwd, profileName, projectId, displayName);
-  writeProfileDocumentWithLock(extensionDir, cwd, personalized);
+  const stored = buildProfileFromAdapter(extensionDir, cwd, profileName, projectId, displayName);
+  writeProfileDocumentWithLock(extensionDir, cwd, stored);
   ensureProjectContextPlaceholder(cwd);
-  return personalized;
+  // Store the reference, hand back the document it resolves to: callers report
+  // and trace what is now in force, not the four lines that point at it.
+  return resolveProjectProfileDocument(findPlatformRoot(extensionDir), stored).profile as ProjectProfile;
 }
 
 function readTask(cwd: string, taskId: string): TaskContract | undefined {
@@ -3727,6 +3724,9 @@ export default function piagentGuard(pi: ExtensionAPI) {
     const permissionHint = ` permission=${permissionProfile.mode}`;
     ctx.ui.notify(`Piagent Pi guard loaded: ${name}${profileHint}${permissionHint}${contextHint}`, preflight.recommendation === "fresh-session" ? "warning" : "info");
     if (!capabilityState.ok) ctx.ui.notify(capabilityState.reason ?? "Capability validation failed.", "warning");
+    if (capabilityState.repinned) {
+      ctx.ui.notify(`Capability lock re-pinned: ${capabilityState.repinned}. The capabilities this project grants are unchanged.`, "info");
+    }
     const legacyWarning = legacyProjectStateWarning(ctx.cwd);
     if (legacyWarning) ctx.ui.notify(legacyWarning, "warning");
     if (permissionProfile.warning) ctx.ui.notify(permissionProfile.warning, "warning");
@@ -4743,10 +4743,12 @@ export default function piagentGuard(pi: ExtensionAPI) {
       entry.context7.digest = snapshot.digest;
       manifest.updatedAt = nowIso();
       fs.writeFileSync(techStackPath(ctx.cwd), `${JSON.stringify(manifest, null, 2)}\n`);
-      const profile = loadProfileFromContext(ctx);
-      if (profile.techStack) {
-        profile.techStack.updatedAt = manifest.updatedAt;
-        writeProfileDocumentWithLock(extensionDir, ctx.cwd, profile);
+      // Write back the document the project stores, not the resolved one: saving
+      // the resolved copy would inline the adapter and stop it following.
+      const stored = readJsonFile<ProjectProfile>(projectProfilePath(ctx.cwd));
+      if (stored?.techStack) {
+        stored.techStack.updatedAt = manifest.updatedAt;
+        writeProfileDocumentWithLock(extensionDir, ctx.cwd, stored);
       }
       appendTrace(ctx.cwd, { event: "profile_tech_context_record", techId, role: entry.role, libraryId: snapshot.resolvedLibraryId });
       appendSessionTrace(pi, { event: "profile_tech_context_record", techId, role: entry.role, libraryId: snapshot.resolvedLibraryId });

package/packages/piagent-core/extensions/project-shape.js

@@ -0,0 +1,285 @@
+import fs from "node:fs";
+import path from "node:path";
+
+// The shape of a repository, in the only terms the profiles care about: is there
+// a frontend, is there a backend, and what else is sitting at the root. Both the
+// runtime recommendation (`piagent_profile_options`) and the shell initialiser
+// (`scripts/init-project.sh`) read it from here. They used to carry separate
+// copies of the same rules, which is how `apps/backend` ended up being invisible
+// to one of them for several releases.
+
+// Directories that name a side of the stack outright. These are matched at the
+// repository root and one level under each workspace root, never at arbitrary
+// depth: `src/api` inside a frontend package is an HTTP client, not a backend.
+const FRONTEND_DIR_NAMES = ["frontend", "web", "client", "ui"];
+const BACKEND_DIR_NAMES = ["backend", "server", "api"];
+const WORKSPACE_ROOTS = ["apps", "packages", "services"];
+
+const FRONTEND_DEPENDENCIES = /"(next|react|vite|vue|svelte|astro|@angular\/core|remix)"/i;
+const BACKEND_DEPENDENCIES = /"(@nestjs|express|fastify|hono|koa|apollo-server|graphql-yoga|prisma|typeorm|sequelize|drizzle-orm)"/i;
+const PYTHON_BACKEND_FRAMEWORKS = /(fastapi|flask|django|litestar|starlite)/i;
+
+const FRONTEND_MARKER_FILES = [
+  "next.config.js",
+  "next.config.mjs",
+  "next.config.ts",
+  "vite.config.js",
+  "vite.config.ts",
+  "src/app",
+  "pages",
+  "public"
+];
+const NODE_BACKEND_MARKER_FILES = ["nest-cli.json", "prisma", "src/server", "src/api"];
+// Markers that identify a backend on their own, with no manifest to lean on.
+const NATIVE_BACKEND_MARKER_FILES = [
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "src/main/java",
+  "src/main/kotlin"
+];
+
+// A workspace file can declare any number of packages. Reading a bounded number
+// of them keeps a repository with hundreds of packages from turning profile
+// recommendation into a directory walk.
+const MAX_WORKSPACE_PACKAGES = 64;
+
+function exists(dir, relative) {
+  try {
+    return fs.existsSync(path.join(dir, relative));
+  } catch {
+    return false;
+  }
+}
+
+// The stack-naming markers are directories. A file called `api` says nothing
+// about a repository having a backend in it.
+function isDirectory(dir, relative) {
+  try {
+    return fs.statSync(path.join(dir, relative)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function readFile(dir, relative) {
+  try {
+    return fs.readFileSync(path.join(dir, relative), "utf8");
+  } catch {
+    return undefined;
+  }
+}
+
+function readJson(dir, relative) {
+  const text = readFile(dir, relative);
+  if (text === undefined) return undefined;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return undefined;
+  }
+}
+
+function stripQuotes(value) {
+  return value.trim().replace(/^['"]/, "").replace(/['"]$/, "").trim();
+}
+
+// npm and yarn put the globs in package.json, pnpm puts them in its own file.
+// Both are read: a repository is free to carry either, and some carry both.
+function readWorkspacePatterns(cwd) {
+  const patterns = [];
+
+  const declared = readJson(cwd, "package.json")?.workspaces;
+  if (Array.isArray(declared)) {
+    patterns.push(...declared);
+  } else if (Array.isArray(declared?.packages)) {
+    patterns.push(...declared.packages);
+  }
+
+  patterns.push(...readPnpmWorkspacePatterns(cwd));
+  return patterns.filter((pattern) => typeof pattern === "string");
+}
+
+// A three-line YAML reader rather than a YAML dependency: this package ships
+// with no runtime dependencies, and the shape being read is a single list of
+// strings under one key.
+function readPnpmWorkspacePatterns(cwd) {
+  const text = readFile(cwd, "pnpm-workspace.yaml") ?? readFile(cwd, "pnpm-workspace.yml");
+  if (text === undefined) return [];
+
+  const patterns = [];
+  let insidePackages = false;
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.replace(/#.*$/, "");
+    if (/^packages\s*:/.test(line)) {
+      insidePackages = true;
+      continue;
+    }
+    if (!insidePackages) continue;
+
+    const item = line.match(/^\s+-\s*(.+?)\s*$/);
+    if (item) {
+      patterns.push(stripQuotes(item[1]));
+      continue;
+    }
+    // A blank line stays inside the list; anything else starts the next key.
+    if (line.trim().length > 0) break;
+  }
+  return patterns;
+}
+
+function expandWorkspacePattern(cwd, pattern) {
+  const normalized = pattern.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+  // `!` excludes rather than includes, and neither an absolute path nor one that
+  // climbs out of the repository is a workspace of this repository.
+  if (!normalized || normalized.startsWith("!") || normalized.startsWith("/")) return [];
+
+  const segments = normalized.split("/").filter((segment) => segment && segment !== ".");
+  if (segments.length === 0 || segments.includes("..")) return [];
+
+  const wildcardAt = segments.findIndex((segment) => segment.includes("*"));
+  if (wildcardAt === -1) return [segments.join("/")];
+  // Only a trailing wildcard is expanded. `packages/*` and `apps/**` are what
+  // workspace files actually declare; anything deeper is left to the directory
+  // and dependency markers instead of growing a glob engine in here.
+  if (wildcardAt !== segments.length - 1) return [];
+
+  const base = segments.slice(0, wildcardAt).join("/");
+  let entries;
+  try {
+    entries = fs.readdirSync(base ? path.join(cwd, base) : cwd, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries
+    .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+    .map((entry) => (base ? `${base}/${entry.name}` : entry.name));
+}
+
+export function readWorkspacePackageDirs(cwd) {
+  const found = [];
+  const seen = new Set();
+  for (const pattern of readWorkspacePatterns(cwd)) {
+    for (const relative of expandWorkspacePattern(cwd, pattern)) {
+      if (seen.has(relative)) continue;
+      if (!exists(cwd, relative)) continue;
+      seen.add(relative);
+      found.push(relative);
+      if (found.length >= MAX_WORKSPACE_PACKAGES) return found;
+    }
+  }
+  return found;
+}
+
+// What one directory says about itself, from its manifest and its own layout.
+// Applied to the repository root and to every declared workspace package, so a
+// pnpm monorepo whose packages are named `web` and `api` is read the same way a
+// single-package repository is.
+function directorySignals(dir) {
+  const manifest = readFile(dir, "package.json");
+  let frontend = false;
+  let backend = false;
+
+  if (manifest !== undefined) {
+    frontend = FRONTEND_DEPENDENCIES.test(manifest);
+    backend = BACKEND_DEPENDENCIES.test(manifest);
+    // Node layout markers only mean something next to a manifest. `public/` and
+    // `pages/` are ordinary directory names in repositories that have nothing to
+    // do with a web framework.
+    if (!frontend) frontend = FRONTEND_MARKER_FILES.some((marker) => exists(dir, marker));
+    if (!backend) backend = NODE_BACKEND_MARKER_FILES.some((marker) => exists(dir, marker));
+  }
+
+  if (!backend) backend = NATIVE_BACKEND_MARKER_FILES.some((marker) => exists(dir, marker));
+
+  const pyproject = readFile(dir, "pyproject.toml");
+  if (pyproject !== undefined && PYTHON_BACKEND_FRAMEWORKS.test(pyproject)) backend = true;
+
+  return { frontend, backend };
+}
+
+function shapeFromDirName(name) {
+  const normalized = name.toLowerCase();
+  if (FRONTEND_DIR_NAMES.includes(normalized)) return "frontend";
+  if (BACKEND_DIR_NAMES.includes(normalized)) return "backend";
+  return undefined;
+}
+
+export function detectProjectShape(cwd) {
+  const hasPackage = exists(cwd, "package.json");
+  const shape = {
+    hasPackage,
+    frontend: false,
+    backend: false,
+    data: false,
+    mobile: false,
+    infra: false,
+    docs: false,
+    workspacePackages: []
+  };
+
+  if (exists(cwd, "pubspec.yaml") || (exists(cwd, "android") && exists(cwd, "ios"))) shape.mobile = true;
+  if (exists(cwd, "dbt_project.yml") || exists(cwd, "dvc.yaml") || exists(cwd, "notebooks") || exists(cwd, "data")) {
+    shape.data = true;
+  }
+  if (exists(cwd, "Dockerfile") || exists(cwd, "docker-compose.yml") || exists(cwd, "compose.yml")
+    || exists(cwd, "compose.yaml") || exists(cwd, "terraform") || exists(cwd, "infra")
+    || exists(cwd, "k8s") || exists(cwd, "helm")) {
+    shape.infra = true;
+  }
+  if (exists(cwd, "docs") || exists(cwd, "mkdocs.yml") || exists(cwd, "mint.json") || exists(cwd, "docusaurus.config.js")) {
+    shape.docs = true;
+  }
+
+  // Directory names are read whether or not the root carries a package.json.
+  // A Django and React repository has `frontend/` and `backend/` and no root
+  // manifest at all; gating this on package.json used to hide both sides of it.
+  for (const name of [...FRONTEND_DIR_NAMES, ...BACKEND_DIR_NAMES]) {
+    const side = shapeFromDirName(name);
+    if (isDirectory(cwd, name)) shape[side] = true;
+    for (const root of WORKSPACE_ROOTS) {
+      if (isDirectory(cwd, `${root}/${name}`)) shape[side] = true;
+    }
+  }
+
+  const rootSignals = directorySignals(cwd);
+  if (rootSignals.frontend) shape.frontend = true;
+  if (rootSignals.backend) shape.backend = true;
+
+  shape.workspacePackages = readWorkspacePackageDirs(cwd);
+  for (const relative of shape.workspacePackages) {
+    const side = shapeFromDirName(path.posix.basename(relative));
+    if (side) shape[side] = true;
+
+    const signals = directorySignals(path.join(cwd, relative));
+    if (signals.frontend) shape.frontend = true;
+    if (signals.backend) shape.backend = true;
+  }
+
+  return shape;
+}
+
+export function detectProfileName(cwd, intent) {
+  const normalizedIntent = typeof intent === "string" ? intent.trim().toLowerCase() : "";
+  if (normalizedIntent === "be-readonly-fe") {
+    return { name: "be-readonly-fe", reason: "User intent says backend should be read-only while frontend is the write target." };
+  }
+  if (normalizedIntent === "frontend-only") return { name: "web-frontend", reason: "User intent says frontend-only." };
+  if (normalizedIntent === "backend-only") return { name: "backend-api", reason: "User intent says backend-only." };
+  if (normalizedIntent === "docs") return { name: "docs", reason: "User intent says docs/docs-only." };
+
+  const shape = detectProjectShape(cwd);
+
+  if (shape.mobile) return { name: "mobile", reason: "Mobile markers found." };
+  if (shape.frontend && shape.backend) {
+    return { name: "fullstack", reason: "Frontend and backend markers both found. Pick be-readonly-fe instead if backend must be read-only." };
+  }
+  if (shape.frontend) return { name: "web-frontend", reason: "Frontend framework markers found." };
+  if (shape.backend) return { name: "backend-api", reason: "Backend/API markers found." };
+  if (shape.data) return { name: "data", reason: "Data/ETL markers found." };
+  if (exists(cwd, "pyproject.toml")) return { name: "python", reason: "Python pyproject.toml found." };
+  if (shape.hasPackage && exists(cwd, "tsconfig.json")) return { name: "node-typescript", reason: "Node TypeScript markers found." };
+  if (shape.infra) return { name: "devops", reason: "Infrastructure markers found." };
+  if (shape.docs) return { name: "docs", reason: "Documentation markers found." };
+  return { name: "generic", reason: "No stronger project markers found." };
+}

package/packages/piagent-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@piagent/core",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "type": "module",
   "private": true,
   "license": "MIT",