mobile-apps: add app.json app identity to telemetry

Switch app correlation to app.json-based appInstanceId, pass resolved working-dir context into hook telemetry emission, and emit appInstanceId as null when unavailable. Update create-mobile-app flow to mint app identity and refresh focused telemetry tests.

Author: Nikhil Agrawal

plugins/mobile-apps/hooks/run-telemetry.js

@@ -30,6 +30,45 @@ function invocationFor(mode, payload) {
   return null;
 }
 
+function pickString(...values) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) return value.trim();
+  }
+  return '';
+}
+
+function parseWorkingDirArg(text) {
+  if (typeof text !== 'string' || !text.trim()) return '';
+  const match = text.match(/--working-dir(?:=|\s+)(?:"([^"]+)"|'([^']+)'|(\S+))/i);
+  return pickString(match && match[1], match && match[2], match && match[3]);
+}
+
+function resolveInvocationCwd(payload) {
+  const toolInput = payload && typeof payload.tool_input === 'object' ? payload.tool_input : null;
+  const fromToolInput = pickString(
+    toolInput && toolInput.cwd,
+    toolInput && toolInput.working_dir,
+    toolInput && toolInput.workingDir,
+  );
+  if (fromToolInput) return fromToolInput;
+
+  const fromToolArgs = toolInput
+    ? pickString(
+      parseWorkingDirArg(toolInput.arguments),
+      parseWorkingDirArg(toolInput.args),
+      parseWorkingDirArg(toolInput.command),
+      parseWorkingDirArg(toolInput.prompt),
+    )
+    : '';
+  if (fromToolArgs) return fromToolArgs;
+
+  return pickString(
+    payload && payload.working_dir,
+    payload && payload.workingDir,
+    payload && payload.cwd,
+  );
+}
+
 async function run(mode) {
   let payload;
   try {
@@ -42,7 +81,13 @@ async function run(mode) {
   if (!skillName) return;
 
   const context = telemetry.createTelemetryContext(payload);
-  if (context) telemetry.emitSkillStarted(context, { skillName, source: mode });
+  if (context) {
+    telemetry.emitSkillStarted(
+      context,
+      { skillName, source: mode },
+      { cwd: resolveInvocationCwd(payload) },
+    );
+  }
 }
 
 function start(mode) {

plugins/mobile-apps/scripts/lib/app-identity.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const APP_JSON_FILE = 'app.json';
+const APP_INSTANCE_ID =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+function isPlainObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function appJsonPath(projectRoot) {
+  return path.join(path.resolve(projectRoot), APP_JSON_FILE);
+}
+
+function readAppInstanceId(projectRoot) {
+  const appJson = readJsonFile(appJsonPath(projectRoot));
+  if (!isPlainObject(appJson) || !isPlainObject(appJson.expo)) return '';
+
+  const extra = appJson.expo.extra;
+  const identity = isPlainObject(extra) && isPlainObject(extra.powerPlatformSkills)
+    ? extra.powerPlatformSkills
+    : null;
+  const appInstanceId = identity && typeof identity.appInstanceId === 'string'
+    ? identity.appInstanceId
+    : '';
+
+  return APP_INSTANCE_ID.test(appInstanceId) ? appInstanceId : '';
+}
+
+function findAppInstanceId(projectRoot = process.cwd()) {
+  if (!projectRoot) return '';
+  return readAppInstanceId(projectRoot);
+}
+
+function ensureAppInstanceId(projectRoot = process.cwd()) {
+  const root = path.resolve(projectRoot);
+  if (!fs.existsSync(root) || !fs.statSync(root).isDirectory()) {
+    throw new Error('Cannot create app identity outside an existing directory');
+  }
+
+  const existing = readAppInstanceId(root);
+  if (existing) return existing;
+
+  const filePath = appJsonPath(root);
+  const appJson = readJsonFile(filePath);
+  const next = isPlainObject(appJson) ? appJson : {};
+  next.expo = isPlainObject(next.expo) ? next.expo : {};
+  next.expo.extra = isPlainObject(next.expo.extra) ? next.expo.extra : {};
+  const skillIdentity = isPlainObject(next.expo.extra.powerPlatformSkills)
+    ? next.expo.extra.powerPlatformSkills
+    : {};
+
+  const appInstanceId = crypto.randomUUID();
+  next.expo.extra.powerPlatformSkills = {
+    ...skillIdentity,
+    schemaVersion: 1,
+    appInstanceId,
+  };
+
+  fs.writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+  return appInstanceId;
+}
+
+module.exports = {
+  APP_JSON_FILE,
+  ensureAppInstanceId,
+  findAppInstanceId,
+};
+
+if (require.main === module) {
+  process.stdout.write(`${ensureAppInstanceId(process.argv[2] || process.cwd())}\n`);
+}

plugins/mobile-apps/scripts/lib/mobile-telemetry.js

@@ -13,6 +13,7 @@ const events = require('./telemetry/lib/events');
 const { fireAndForget } = require('./telemetry/lib/emit-spawn');
 const { loadResolver } = require('./telemetry/lib/resolver-loader');
 const session = require('./telemetry/lib/session');
+const { findAppInstanceId } = require('./app-identity');
 
 function readPluginVersion() {
   const manifestPath = path.resolve(__dirname, '..', '..', '.claude-plugin', 'plugin.json');
@@ -236,7 +237,15 @@ function commonFields(context, invocation, opts = {}) {
     nodeVersion: `v${String(process.versions.node).split('.')[0]}`,
     skillName: invocation.skillName,
   };
-  if (invocation.source) fields.eventInfo = { invocationSource: invocation.source };
+
+  // `eventInfo` is the shared schema's caller-supplied JSON field, so app
+  // identity rides here rather than needing a new allowlisted column.
+  const eventInfo = {};
+  if (invocation.source) eventInfo.invocationSource = invocation.source;
+  const appInstanceId = findAppInstanceId(opts.cwd) || null;
+  eventInfo.appInstanceId = appInstanceId;
+  if (Object.keys(eventInfo).length) fields.eventInfo = eventInfo;
+
   if (ai.aiAgentName) fields.aiAgentName = ai.aiAgentName;
   if (ai.aiAgentVersion) fields.aiAgentVersion = ai.aiAgentVersion;
   return fields;

plugins/mobile-apps/scripts/tests/mobile-telemetry-hooks.test.js

@@ -243,7 +243,10 @@ test('prompt hook builds the Mobile Apps CS4 envelope without real network acces
   assert.match(envelope.data.nodeVersion, /^v\d+$/);
   assert.equal(envelope.data.skillName, 'deploy');
   assert.equal(typeof envelope.data.eventInfo, 'string');
-  assert.deepEqual(JSON.parse(envelope.data.eventInfo), { invocationSource: 'prompt' });
+  assert.deepEqual(JSON.parse(envelope.data.eventInfo), {
+    invocationSource: 'prompt',
+    appInstanceId: null,
+  });
   for (const forbidden of [
     'orgId',
     'tenantId',
@@ -275,6 +278,7 @@ test('bare command outside a mobile project emits a start', (t) => {
   assert.equal(records.length, 1);
   assert.equal(records[0].data.skillName, 'deploy');
   assert.equal(records[0].data.eventInfo.invocationSource, 'prompt');
+  assert.equal(records[0].data.eventInfo.appInstanceId, null);
 });
 
 test('manual Copilot slash command emits after host expansion', (t) => {
@@ -289,6 +293,73 @@ test('manual Copilot slash command emits after host expansion', (t) => {
   assert.equal(records.length, 1);
   assert.equal(records[0].data.skillName, 'add-connector');
   assert.equal(records[0].data.eventInfo.invocationSource, 'prompt');
+  assert.equal(records[0].data.eventInfo.appInstanceId, null);
+});
+
+test('hook attaches app identity from app.json when cwd is a project root', (t) => {
+  const context = fixture(t);
+  fs.writeFileSync(
+    path.join(context.projectRoot, 'app.json'),
+    JSON.stringify({
+      expo: {
+        extra: {
+          powerPlatformSkills: {
+            schemaVersion: 1,
+            appInstanceId: '5d7e71b1-61d6-4a91-9c2e-cba5db983e38',
+          },
+        },
+      },
+    }),
+  );
+
+  assert.equal(runHook('pretool', {
+    cwd: context.projectRoot,
+    session_id: 'session-1',
+    tool_input: { skill: 'deploy' },
+  }, context).status, 0);
+
+  const records = waitForEvents(context, 1);
+  assert.equal(records.length, 1);
+  assert.equal(records[0].data.eventInfo.invocationSource, 'pretool');
+  assert.equal(
+    records[0].data.eventInfo.appInstanceId,
+    '5d7e71b1-61d6-4a91-9c2e-cba5db983e38',
+  );
+});
+
+test('hook resolves --working-dir from tool input when cwd is outside the project', (t) => {
+  const context = fixture(t);
+  fs.writeFileSync(
+    path.join(context.projectRoot, 'app.json'),
+    JSON.stringify({
+      expo: {
+        extra: {
+          powerPlatformSkills: {
+            schemaVersion: 1,
+            appInstanceId: 'e5b2f43c-fa9f-44a0-b8a7-54e4f956f9db',
+          },
+        },
+      },
+    }),
+  );
+  const unrelated = path.join(context.root, 'outside');
+  fs.mkdirSync(unrelated);
+
+  assert.equal(runHook('pretool', {
+    cwd: unrelated,
+    session_id: 'session-1',
+    tool_input: {
+      skill: 'deploy',
+      arguments: `--working-dir "${context.projectRoot}" --non-interactive`,
+    },
+  }, context).status, 0);
+
+  const records = waitForEvents(context, 1);
+  assert.equal(records.length, 1);
+  assert.equal(
+    records[0].data.eventInfo.appInstanceId,
+    'e5b2f43c-fa9f-44a0-b8a7-54e4f956f9db',
+  );
 });
 
 test('another plugin namespace and embedded command are no-ops', (t) => {

plugins/mobile-apps/scripts/tests/mobile-telemetry.test.js

@@ -11,6 +11,7 @@ const {
   createTelemetryContext,
   emitSkillStarted,
 } = require('../lib/mobile-telemetry');
+const { ensureAppInstanceId, findAppInstanceId } = require('../lib/app-identity');
 
 const PLUGIN_ROOT = path.resolve(__dirname, '..', '..');
 const TELEMETRY_CLI = path.join(
@@ -31,6 +32,14 @@ function tempConfig(config) {
   return { dir, ikeyPath };
 }
 
+// An empty directory keeps app-identity lookup out of the repo checkout, so
+// event assertions do not depend on where the suite happens to run.
+function tempProject(t) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mobile-app-project-'));
+  t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+  return dir;
+}
+
 function contextFor(config) {
   const { dir, ikeyPath } = tempConfig(config);
   return createTelemetryContext(
@@ -159,26 +168,81 @@ test('expired Copilot alias does not outlive unavailable host state', (t) => {
   assert.equal(expired.sessionId, nestedSessionId);
 });
 
-test('started event is allowlisted and carries no user, tenant, prompt, or path data', () => {
+test('started event is allowlisted and carries no user, tenant, prompt, or path data', (t) => {
   const context = contextFor(provisioned);
   let captured;
   const event = emitSkillStarted(context, invocation, {
     emit: (value) => { captured = value; },
     readAiAgent: () => ({ aiAgentName: 'GitHub Copilot', aiAgentVersion: '1.2.3' }),
     correlationId: 'correlation-1',
+    cwd: tempProject(t),
   });
   assert.equal(captured, event);
   assert.equal(event.data.eventName, 'skill_started');
   assert.equal(event.data.pluginName, 'mobile-app');
   assert.equal(event.data.skillName, 'deploy');
   assert.equal(event.data.sessionId, 'session-1');
   assert.equal(event.data.correlationId, 'correlation-1');
-  assert.deepEqual(event.data.eventInfo, { invocationSource: 'pretool' });
+  assert.deepEqual(event.data.eventInfo, { invocationSource: 'pretool', appInstanceId: null });
   for (const forbidden of ['orgId', 'tenantId', 'pacCliVersion', 'aadObjectId', 'prompt', 'cwd', 'path']) {
     assert.equal(Object.prototype.hasOwnProperty.call(event.data, forbidden), false);
   }
 });
 
+test('app instance id is minted once and reused by later skill runs', (t) => {
+  const project = tempProject(t);
+  const appInstanceId = ensureAppInstanceId(project);
+  assert.match(appInstanceId, /^[0-9a-f-]{36}$/);
+  assert.equal(ensureAppInstanceId(project), appInstanceId);
+  assert.equal(findAppInstanceId(project), appInstanceId);
+  assert.equal(findAppInstanceId(path.join(project, 'src', 'screens')), '');
+});
+
+test('events outside a project carry no app identity', (t) => {
+  assert.equal(findAppInstanceId(tempProject(t)), '');
+});
+
+test('a hand-edited app identity is ignored rather than emitted', (t) => {
+  const project = tempProject(t);
+  fs.writeFileSync(
+    path.join(project, 'app.json'),
+    JSON.stringify({
+      expo: {
+        extra: {
+          powerPlatformSkills: {
+            schemaVersion: 1,
+            appInstanceId: 'contoso-field-inspections',
+          },
+        },
+      },
+    }),
+  );
+  assert.equal(findAppInstanceId(project), '');
+});
+
+test('two apps in one session emit distinct app identities', (t) => {
+  const context = contextFor(provisioned);
+  const emitFrom = (project) => emitSkillStarted(context, invocation, {
+    emit: () => {},
+    readAiAgent: () => ({}),
+    cwd: project,
+  }).data;
+
+  const first = emitFrom(tempProject(t));
+  const second = emitFrom(tempProject(t));
+  assert.equal(first.sessionId, second.sessionId);
+  assert.equal(first.eventInfo.appInstanceId, null);
+
+  const projectA = tempProject(t);
+  const projectB = tempProject(t);
+  ensureAppInstanceId(projectA);
+  ensureAppInstanceId(projectB);
+  const a = emitFrom(projectA);
+  const b = emitFrom(projectB);
+  assert.notEqual(a.eventInfo.appInstanceId, b.eventInfo.appInstanceId);
+  assert.equal(a.sessionId, b.sessionId);
+});
+
 test('bundled telemetry library is byte-identical to the canonical shared source', (t) => {
   if (!fs.existsSync(SHARED_TELEMETRY_LIB)) {
     t.skip('canonical shared source is unavailable in an installed plugin');

plugins/mobile-apps/skills/create-mobile-app/SKILL.md

@@ -930,8 +930,11 @@ This is the **Scaffold gate** from the TypeScript Gate Policy. If it fails, capt
 
 ```bash
 cp "${CLAUDE_SKILL_DIR}/../../shared/memory-bank.md" "<working_dir>/memory-bank.md"
+node "${CLAUDE_SKILL_DIR}/../../scripts/lib/app-identity.js" "<working_dir>"
 ```
 
+`app-identity.js` mints `app.json` `expo.extra.powerPlatformSkills.appInstanceId` — a random per-project ID that lets usage telemetry tell this app apart from other apps built in the same session, and recognize it again in later sessions. It is idempotent, so a resume or re-run keeps the original ID. It contains no app name, path, or environment data. Commit it: it is the app's identity, not a per-machine cache.
+
 Fill in the Project facts and Power Platform context sections from Steps 2 and 4. From here on, every step appends to the relevant section of `<working_dir>/memory-bank.md` immediately after success — not at the end. This is what enables Step 0's resume on a future run.
 
 Immediately after creating `memory-bank.md`, flush any queued planner concerns from `DEFERRED_CONCERNS[]` into `## Concerns` (append-only). This flush is unconditional: if the queue is non-empty, write it now before continuing to Step 6.75.